"Fossies" - the Fresh Open Source Software Archive

Member "cells-3.0.3/vendor/github.com/ugorji/go/codec/fast-path.generated.go" (30 Nov 2021, 957955 Bytes) of package /linux/misc/pydio-cells-3.0.3.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Go source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    1 // +build !notfastpath
    2 
    3 // Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
    4 // Use of this source code is governed by a MIT license found in the LICENSE file.
    5 
    6 // ************************************************************
    7 // DO NOT EDIT.
    8 // THIS FILE IS AUTO-GENERATED from fast-path.go.tmpl
    9 // ************************************************************
   10 
   11 package codec
   12 
   13 // Fast path functions try to create a fast path encode or decode implementation
   14 // for common maps and slices.
   15 //
   16 // We define the functions and register then in this single file
   17 // so as not to pollute the encode.go and decode.go, and create a dependency in there.
   18 // This file can be omitted without causing a build failure.
   19 //
   20 // The advantage of fast paths is:
   21 //    - Many calls bypass reflection altogether
   22 //
   23 // Currently support
   24 //    - slice of all builtin types,
   25 //    - map of all builtin types to string or interface value
   26 //    - symmetrical maps of all builtin types (e.g. str-str, uint8-uint8)
   27 // This should provide adequate "typical" implementations.
   28 //
   29 // Note that fast track decode functions must handle values for which an address cannot be obtained.
   30 // For example:
   31 //   m2 := map[string]int{}
   32 //   p2 := []interface{}{m2}
   33 //   // decoding into p2 will bomb if fast track functions do not treat like unaddressable.
   34 //
   35 
   36 import (
   37     "reflect"
   38     "sort"
   39 )
   40 
   41 const fastpathEnabled = true
   42 
   43 const fastpathCheckNilFalse = false // for reflect
   44 const fastpathCheckNilTrue = true   // for type switch
   45 
   46 type fastpathT struct{}
   47 
   48 var fastpathTV fastpathT
   49 
   50 type fastpathE struct {
   51     rtid  uintptr
   52     rt    reflect.Type
   53     encfn func(*encFnInfo, reflect.Value)
   54     decfn func(*decFnInfo, reflect.Value)
   55 }
   56 
   57 type fastpathA [271]fastpathE
   58 
   59 func (x *fastpathA) index(rtid uintptr) int {
   60     // use binary search to grab the index (adapted from sort/search.go)
   61     h, i, j := 0, 0, 271 // len(x)
   62     for i < j {
   63         h = i + (j-i)/2
   64         if x[h].rtid < rtid {
   65             i = h + 1
   66         } else {
   67             j = h
   68         }
   69     }
   70     if i < 271 && x[i].rtid == rtid {
   71         return i
   72     }
   73     return -1
   74 }
   75 
   76 type fastpathAslice []fastpathE
   77 
   78 func (x fastpathAslice) Len() int           { return len(x) }
   79 func (x fastpathAslice) Less(i, j int) bool { return x[i].rtid < x[j].rtid }
   80 func (x fastpathAslice) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
   81 
   82 var fastpathAV fastpathA
   83 
   84 // due to possible initialization loop error, make fastpath in an init()
   85 func init() {
   86     i := 0
   87     fn := func(v interface{}, fe func(*encFnInfo, reflect.Value), fd func(*decFnInfo, reflect.Value)) (f fastpathE) {
   88         xrt := reflect.TypeOf(v)
   89         xptr := reflect.ValueOf(xrt).Pointer()
   90         fastpathAV[i] = fastpathE{xptr, xrt, fe, fd}
   91         i++
   92         return
   93     }
   94 
   95     fn([]interface{}(nil), (*encFnInfo).fastpathEncSliceIntfR, (*decFnInfo).fastpathDecSliceIntfR)
   96     fn([]string(nil), (*encFnInfo).fastpathEncSliceStringR, (*decFnInfo).fastpathDecSliceStringR)
   97     fn([]float32(nil), (*encFnInfo).fastpathEncSliceFloat32R, (*decFnInfo).fastpathDecSliceFloat32R)
   98     fn([]float64(nil), (*encFnInfo).fastpathEncSliceFloat64R, (*decFnInfo).fastpathDecSliceFloat64R)
   99     fn([]uint(nil), (*encFnInfo).fastpathEncSliceUintR, (*decFnInfo).fastpathDecSliceUintR)
  100     fn([]uint16(nil), (*encFnInfo).fastpathEncSliceUint16R, (*decFnInfo).fastpathDecSliceUint16R)
  101     fn([]uint32(nil), (*encFnInfo).fastpathEncSliceUint32R, (*decFnInfo).fastpathDecSliceUint32R)
  102     fn([]uint64(nil), (*encFnInfo).fastpathEncSliceUint64R, (*decFnInfo).fastpathDecSliceUint64R)
  103     fn([]uintptr(nil), (*encFnInfo).fastpathEncSliceUintptrR, (*decFnInfo).fastpathDecSliceUintptrR)
  104     fn([]int(nil), (*encFnInfo).fastpathEncSliceIntR, (*decFnInfo).fastpathDecSliceIntR)
  105     fn([]int8(nil), (*encFnInfo).fastpathEncSliceInt8R, (*decFnInfo).fastpathDecSliceInt8R)
  106     fn([]int16(nil), (*encFnInfo).fastpathEncSliceInt16R, (*decFnInfo).fastpathDecSliceInt16R)
  107     fn([]int32(nil), (*encFnInfo).fastpathEncSliceInt32R, (*decFnInfo).fastpathDecSliceInt32R)
  108     fn([]int64(nil), (*encFnInfo).fastpathEncSliceInt64R, (*decFnInfo).fastpathDecSliceInt64R)
  109     fn([]bool(nil), (*encFnInfo).fastpathEncSliceBoolR, (*decFnInfo).fastpathDecSliceBoolR)
  110 
  111     fn(map[interface{}]interface{}(nil), (*encFnInfo).fastpathEncMapIntfIntfR, (*decFnInfo).fastpathDecMapIntfIntfR)
  112     fn(map[interface{}]string(nil), (*encFnInfo).fastpathEncMapIntfStringR, (*decFnInfo).fastpathDecMapIntfStringR)
  113     fn(map[interface{}]uint(nil), (*encFnInfo).fastpathEncMapIntfUintR, (*decFnInfo).fastpathDecMapIntfUintR)
  114     fn(map[interface{}]uint8(nil), (*encFnInfo).fastpathEncMapIntfUint8R, (*decFnInfo).fastpathDecMapIntfUint8R)
  115     fn(map[interface{}]uint16(nil), (*encFnInfo).fastpathEncMapIntfUint16R, (*decFnInfo).fastpathDecMapIntfUint16R)
  116     fn(map[interface{}]uint32(nil), (*encFnInfo).fastpathEncMapIntfUint32R, (*decFnInfo).fastpathDecMapIntfUint32R)
  117     fn(map[interface{}]uint64(nil), (*encFnInfo).fastpathEncMapIntfUint64R, (*decFnInfo).fastpathDecMapIntfUint64R)
  118     fn(map[interface{}]uintptr(nil), (*encFnInfo).fastpathEncMapIntfUintptrR, (*decFnInfo).fastpathDecMapIntfUintptrR)
  119     fn(map[interface{}]int(nil), (*encFnInfo).fastpathEncMapIntfIntR, (*decFnInfo).fastpathDecMapIntfIntR)
  120     fn(map[interface{}]int8(nil), (*encFnInfo).fastpathEncMapIntfInt8R, (*decFnInfo).fastpathDecMapIntfInt8R)
  121     fn(map[interface{}]int16(nil), (*encFnInfo).fastpathEncMapIntfInt16R, (*decFnInfo).fastpathDecMapIntfInt16R)
  122     fn(map[interface{}]int32(nil), (*encFnInfo).fastpathEncMapIntfInt32R, (*decFnInfo).fastpathDecMapIntfInt32R)
  123     fn(map[interface{}]int64(nil), (*encFnInfo).fastpathEncMapIntfInt64R, (*decFnInfo).fastpathDecMapIntfInt64R)
  124     fn(map[interface{}]float32(nil), (*encFnInfo).fastpathEncMapIntfFloat32R, (*decFnInfo).fastpathDecMapIntfFloat32R)
  125     fn(map[interface{}]float64(nil), (*encFnInfo).fastpathEncMapIntfFloat64R, (*decFnInfo).fastpathDecMapIntfFloat64R)
  126     fn(map[interface{}]bool(nil), (*encFnInfo).fastpathEncMapIntfBoolR, (*decFnInfo).fastpathDecMapIntfBoolR)
  127     fn(map[string]interface{}(nil), (*encFnInfo).fastpathEncMapStringIntfR, (*decFnInfo).fastpathDecMapStringIntfR)
  128     fn(map[string]string(nil), (*encFnInfo).fastpathEncMapStringStringR, (*decFnInfo).fastpathDecMapStringStringR)
  129     fn(map[string]uint(nil), (*encFnInfo).fastpathEncMapStringUintR, (*decFnInfo).fastpathDecMapStringUintR)
  130     fn(map[string]uint8(nil), (*encFnInfo).fastpathEncMapStringUint8R, (*decFnInfo).fastpathDecMapStringUint8R)
  131     fn(map[string]uint16(nil), (*encFnInfo).fastpathEncMapStringUint16R, (*decFnInfo).fastpathDecMapStringUint16R)
  132     fn(map[string]uint32(nil), (*encFnInfo).fastpathEncMapStringUint32R, (*decFnInfo).fastpathDecMapStringUint32R)
  133     fn(map[string]uint64(nil), (*encFnInfo).fastpathEncMapStringUint64R, (*decFnInfo).fastpathDecMapStringUint64R)
  134     fn(map[string]uintptr(nil), (*encFnInfo).fastpathEncMapStringUintptrR, (*decFnInfo).fastpathDecMapStringUintptrR)
  135     fn(map[string]int(nil), (*encFnInfo).fastpathEncMapStringIntR, (*decFnInfo).fastpathDecMapStringIntR)
  136     fn(map[string]int8(nil), (*encFnInfo).fastpathEncMapStringInt8R, (*decFnInfo).fastpathDecMapStringInt8R)
  137     fn(map[string]int16(nil), (*encFnInfo).fastpathEncMapStringInt16R, (*decFnInfo).fastpathDecMapStringInt16R)
  138     fn(map[string]int32(nil), (*encFnInfo).fastpathEncMapStringInt32R, (*decFnInfo).fastpathDecMapStringInt32R)
  139     fn(map[string]int64(nil), (*encFnInfo).fastpathEncMapStringInt64R, (*decFnInfo).fastpathDecMapStringInt64R)
  140     fn(map[string]float32(nil), (*encFnInfo).fastpathEncMapStringFloat32R, (*decFnInfo).fastpathDecMapStringFloat32R)
  141     fn(map[string]float64(nil), (*encFnInfo).fastpathEncMapStringFloat64R, (*decFnInfo).fastpathDecMapStringFloat64R)
  142     fn(map[string]bool(nil), (*encFnInfo).fastpathEncMapStringBoolR, (*decFnInfo).fastpathDecMapStringBoolR)
  143     fn(map[float32]interface{}(nil), (*encFnInfo).fastpathEncMapFloat32IntfR, (*decFnInfo).fastpathDecMapFloat32IntfR)
  144     fn(map[float32]string(nil), (*encFnInfo).fastpathEncMapFloat32StringR, (*decFnInfo).fastpathDecMapFloat32StringR)
  145     fn(map[float32]uint(nil), (*encFnInfo).fastpathEncMapFloat32UintR, (*decFnInfo).fastpathDecMapFloat32UintR)
  146     fn(map[float32]uint8(nil), (*encFnInfo).fastpathEncMapFloat32Uint8R, (*decFnInfo).fastpathDecMapFloat32Uint8R)
  147     fn(map[float32]uint16(nil), (*encFnInfo).fastpathEncMapFloat32Uint16R, (*decFnInfo).fastpathDecMapFloat32Uint16R)
  148     fn(map[float32]uint32(nil), (*encFnInfo).fastpathEncMapFloat32Uint32R, (*decFnInfo).fastpathDecMapFloat32Uint32R)
  149     fn(map[float32]uint64(nil), (*encFnInfo).fastpathEncMapFloat32Uint64R, (*decFnInfo).fastpathDecMapFloat32Uint64R)
  150     fn(map[float32]uintptr(nil), (*encFnInfo).fastpathEncMapFloat32UintptrR, (*decFnInfo).fastpathDecMapFloat32UintptrR)
  151     fn(map[float32]int(nil), (*encFnInfo).fastpathEncMapFloat32IntR, (*decFnInfo).fastpathDecMapFloat32IntR)
  152     fn(map[float32]int8(nil), (*encFnInfo).fastpathEncMapFloat32Int8R, (*decFnInfo).fastpathDecMapFloat32Int8R)
  153     fn(map[float32]int16(nil), (*encFnInfo).fastpathEncMapFloat32Int16R, (*decFnInfo).fastpathDecMapFloat32Int16R)
  154     fn(map[float32]int32(nil), (*encFnInfo).fastpathEncMapFloat32Int32R, (*decFnInfo).fastpathDecMapFloat32Int32R)
  155     fn(map[float32]int64(nil), (*encFnInfo).fastpathEncMapFloat32Int64R, (*decFnInfo).fastpathDecMapFloat32Int64R)
  156     fn(map[float32]float32(nil), (*encFnInfo).fastpathEncMapFloat32Float32R, (*decFnInfo).fastpathDecMapFloat32Float32R)
  157     fn(map[float32]float64(nil), (*encFnInfo).fastpathEncMapFloat32Float64R, (*decFnInfo).fastpathDecMapFloat32Float64R)
  158     fn(map[float32]bool(nil), (*encFnInfo).fastpathEncMapFloat32BoolR, (*decFnInfo).fastpathDecMapFloat32BoolR)
  159     fn(map[float64]interface{}(nil), (*encFnInfo).fastpathEncMapFloat64IntfR, (*decFnInfo).fastpathDecMapFloat64IntfR)
  160     fn(map[float64]string(nil), (*encFnInfo).fastpathEncMapFloat64StringR, (*decFnInfo).fastpathDecMapFloat64StringR)
  161     fn(map[float64]uint(nil), (*encFnInfo).fastpathEncMapFloat64UintR, (*decFnInfo).fastpathDecMapFloat64UintR)
  162     fn(map[float64]uint8(nil), (*encFnInfo).fastpathEncMapFloat64Uint8R, (*decFnInfo).fastpathDecMapFloat64Uint8R)
  163     fn(map[float64]uint16(nil), (*encFnInfo).fastpathEncMapFloat64Uint16R, (*decFnInfo).fastpathDecMapFloat64Uint16R)
  164     fn(map[float64]uint32(nil), (*encFnInfo).fastpathEncMapFloat64Uint32R, (*decFnInfo).fastpathDecMapFloat64Uint32R)
  165     fn(map[float64]uint64(nil), (*encFnInfo).fastpathEncMapFloat64Uint64R, (*decFnInfo).fastpathDecMapFloat64Uint64R)
  166     fn(map[float64]uintptr(nil), (*encFnInfo).fastpathEncMapFloat64UintptrR, (*decFnInfo).fastpathDecMapFloat64UintptrR)
  167     fn(map[float64]int(nil), (*encFnInfo).fastpathEncMapFloat64IntR, (*decFnInfo).fastpathDecMapFloat64IntR)
  168     fn(map[float64]int8(nil), (*encFnInfo).fastpathEncMapFloat64Int8R, (*decFnInfo).fastpathDecMapFloat64Int8R)
  169     fn(map[float64]int16(nil), (*encFnInfo).fastpathEncMapFloat64Int16R, (*decFnInfo).fastpathDecMapFloat64Int16R)
  170     fn(map[float64]int32(nil), (*encFnInfo).fastpathEncMapFloat64Int32R, (*decFnInfo).fastpathDecMapFloat64Int32R)
  171     fn(map[float64]int64(nil), (*encFnInfo).fastpathEncMapFloat64Int64R, (*decFnInfo).fastpathDecMapFloat64Int64R)
  172     fn(map[float64]float32(nil), (*encFnInfo).fastpathEncMapFloat64Float32R, (*decFnInfo).fastpathDecMapFloat64Float32R)
  173     fn(map[float64]float64(nil), (*encFnInfo).fastpathEncMapFloat64Float64R, (*decFnInfo).fastpathDecMapFloat64Float64R)
  174     fn(map[float64]bool(nil), (*encFnInfo).fastpathEncMapFloat64BoolR, (*decFnInfo).fastpathDecMapFloat64BoolR)
  175     fn(map[uint]interface{}(nil), (*encFnInfo).fastpathEncMapUintIntfR, (*decFnInfo).fastpathDecMapUintIntfR)
  176     fn(map[uint]string(nil), (*encFnInfo).fastpathEncMapUintStringR, (*decFnInfo).fastpathDecMapUintStringR)
  177     fn(map[uint]uint(nil), (*encFnInfo).fastpathEncMapUintUintR, (*decFnInfo).fastpathDecMapUintUintR)
  178     fn(map[uint]uint8(nil), (*encFnInfo).fastpathEncMapUintUint8R, (*decFnInfo).fastpathDecMapUintUint8R)
  179     fn(map[uint]uint16(nil), (*encFnInfo).fastpathEncMapUintUint16R, (*decFnInfo).fastpathDecMapUintUint16R)
  180     fn(map[uint]uint32(nil), (*encFnInfo).fastpathEncMapUintUint32R, (*decFnInfo).fastpathDecMapUintUint32R)
  181     fn(map[uint]uint64(nil), (*encFnInfo).fastpathEncMapUintUint64R, (*decFnInfo).fastpathDecMapUintUint64R)
  182     fn(map[uint]uintptr(nil), (*encFnInfo).fastpathEncMapUintUintptrR, (*decFnInfo).fastpathDecMapUintUintptrR)
  183     fn(map[uint]int(nil), (*encFnInfo).fastpathEncMapUintIntR, (*decFnInfo).fastpathDecMapUintIntR)
  184     fn(map[uint]int8(nil), (*encFnInfo).fastpathEncMapUintInt8R, (*decFnInfo).fastpathDecMapUintInt8R)
  185     fn(map[uint]int16(nil), (*encFnInfo).fastpathEncMapUintInt16R, (*decFnInfo).fastpathDecMapUintInt16R)
  186     fn(map[uint]int32(nil), (*encFnInfo).fastpathEncMapUintInt32R, (*decFnInfo).fastpathDecMapUintInt32R)
  187     fn(map[uint]int64(nil), (*encFnInfo).fastpathEncMapUintInt64R, (*decFnInfo).fastpathDecMapUintInt64R)
  188     fn(map[uint]float32(nil), (*encFnInfo).fastpathEncMapUintFloat32R, (*decFnInfo).fastpathDecMapUintFloat32R)
  189     fn(map[uint]float64(nil), (*encFnInfo).fastpathEncMapUintFloat64R, (*decFnInfo).fastpathDecMapUintFloat64R)
  190     fn(map[uint]bool(nil), (*encFnInfo).fastpathEncMapUintBoolR, (*decFnInfo).fastpathDecMapUintBoolR)
  191     fn(map[uint8]interface{}(nil), (*encFnInfo).fastpathEncMapUint8IntfR, (*decFnInfo).fastpathDecMapUint8IntfR)
  192     fn(map[uint8]string(nil), (*encFnInfo).fastpathEncMapUint8StringR, (*decFnInfo).fastpathDecMapUint8StringR)
  193     fn(map[uint8]uint(nil), (*encFnInfo).fastpathEncMapUint8UintR, (*decFnInfo).fastpathDecMapUint8UintR)
  194     fn(map[uint8]uint8(nil), (*encFnInfo).fastpathEncMapUint8Uint8R, (*decFnInfo).fastpathDecMapUint8Uint8R)
  195     fn(map[uint8]uint16(nil), (*encFnInfo).fastpathEncMapUint8Uint16R, (*decFnInfo).fastpathDecMapUint8Uint16R)
  196     fn(map[uint8]uint32(nil), (*encFnInfo).fastpathEncMapUint8Uint32R, (*decFnInfo).fastpathDecMapUint8Uint32R)
  197     fn(map[uint8]uint64(nil), (*encFnInfo).fastpathEncMapUint8Uint64R, (*decFnInfo).fastpathDecMapUint8Uint64R)
  198     fn(map[uint8]uintptr(nil), (*encFnInfo).fastpathEncMapUint8UintptrR, (*decFnInfo).fastpathDecMapUint8UintptrR)
  199     fn(map[uint8]int(nil), (*encFnInfo).fastpathEncMapUint8IntR, (*decFnInfo).fastpathDecMapUint8IntR)
  200     fn(map[uint8]int8(nil), (*encFnInfo).fastpathEncMapUint8Int8R, (*decFnInfo).fastpathDecMapUint8Int8R)
  201     fn(map[uint8]int16(nil), (*encFnInfo).fastpathEncMapUint8Int16R, (*decFnInfo).fastpathDecMapUint8Int16R)
  202     fn(map[uint8]int32(nil), (*encFnInfo).fastpathEncMapUint8Int32R, (*decFnInfo).fastpathDecMapUint8Int32R)
  203     fn(map[uint8]int64(nil), (*encFnInfo).fastpathEncMapUint8Int64R, (*decFnInfo).fastpathDecMapUint8Int64R)
  204     fn(map[uint8]float32(nil), (*encFnInfo).fastpathEncMapUint8Float32R, (*decFnInfo).fastpathDecMapUint8Float32R)
  205     fn(map[uint8]float64(nil), (*encFnInfo).fastpathEncMapUint8Float64R, (*decFnInfo).fastpathDecMapUint8Float64R)
  206     fn(map[uint8]bool(nil), (*encFnInfo).fastpathEncMapUint8BoolR, (*decFnInfo).fastpathDecMapUint8BoolR)
  207     fn(map[uint16]interface{}(nil), (*encFnInfo).fastpathEncMapUint16IntfR, (*decFnInfo).fastpathDecMapUint16IntfR)
  208     fn(map[uint16]string(nil), (*encFnInfo).fastpathEncMapUint16StringR, (*decFnInfo).fastpathDecMapUint16StringR)
  209     fn(map[uint16]uint(nil), (*encFnInfo).fastpathEncMapUint16UintR, (*decFnInfo).fastpathDecMapUint16UintR)
  210     fn(map[uint16]uint8(nil), (*encFnInfo).fastpathEncMapUint16Uint8R, (*decFnInfo).fastpathDecMapUint16Uint8R)
  211     fn(map[uint16]uint16(nil), (*encFnInfo).fastpathEncMapUint16Uint16R, (*decFnInfo).fastpathDecMapUint16Uint16R)
  212     fn(map[uint16]uint32(nil), (*encFnInfo).fastpathEncMapUint16Uint32R, (*decFnInfo).fastpathDecMapUint16Uint32R)
  213     fn(map[uint16]uint64(nil), (*encFnInfo).fastpathEncMapUint16Uint64R, (*decFnInfo).fastpathDecMapUint16Uint64R)
  214     fn(map[uint16]uintptr(nil), (*encFnInfo).fastpathEncMapUint16UintptrR, (*decFnInfo).fastpathDecMapUint16UintptrR)
  215     fn(map[uint16]int(nil), (*encFnInfo).fastpathEncMapUint16IntR, (*decFnInfo).fastpathDecMapUint16IntR)
  216     fn(map[uint16]int8(nil), (*encFnInfo).fastpathEncMapUint16Int8R, (*decFnInfo).fastpathDecMapUint16Int8R)
  217     fn(map[uint16]int16(nil), (*encFnInfo).fastpathEncMapUint16Int16R, (*decFnInfo).fastpathDecMapUint16Int16R)
  218     fn(map[uint16]int32(nil), (*encFnInfo).fastpathEncMapUint16Int32R, (*decFnInfo).fastpathDecMapUint16Int32R)
  219     fn(map[uint16]int64(nil), (*encFnInfo).fastpathEncMapUint16Int64R, (*decFnInfo).fastpathDecMapUint16Int64R)
  220     fn(map[uint16]float32(nil), (*encFnInfo).fastpathEncMapUint16Float32R, (*decFnInfo).fastpathDecMapUint16Float32R)
  221     fn(map[uint16]float64(nil), (*encFnInfo).fastpathEncMapUint16Float64R, (*decFnInfo).fastpathDecMapUint16Float64R)
  222     fn(map[uint16]bool(nil), (*encFnInfo).fastpathEncMapUint16BoolR, (*decFnInfo).fastpathDecMapUint16BoolR)
  223     fn(map[uint32]interface{}(nil), (*encFnInfo).fastpathEncMapUint32IntfR, (*decFnInfo).fastpathDecMapUint32IntfR)
  224     fn(map[uint32]string(nil), (*encFnInfo).fastpathEncMapUint32StringR, (*decFnInfo).fastpathDecMapUint32StringR)
  225     fn(map[uint32]uint(nil), (*encFnInfo).fastpathEncMapUint32UintR, (*decFnInfo).fastpathDecMapUint32UintR)
  226     fn(map[uint32]uint8(nil), (*encFnInfo).fastpathEncMapUint32Uint8R, (*decFnInfo).fastpathDecMapUint32Uint8R)
  227     fn(map[uint32]uint16(nil), (*encFnInfo).fastpathEncMapUint32Uint16R, (*decFnInfo).fastpathDecMapUint32Uint16R)
  228     fn(map[uint32]uint32(nil), (*encFnInfo).fastpathEncMapUint32Uint32R, (*decFnInfo).fastpathDecMapUint32Uint32R)
  229     fn(map[uint32]uint64(nil), (*encFnInfo).fastpathEncMapUint32Uint64R, (*decFnInfo).fastpathDecMapUint32Uint64R)
  230     fn(map[uint32]uintptr(nil), (*encFnInfo).fastpathEncMapUint32UintptrR, (*decFnInfo).fastpathDecMapUint32UintptrR)
  231     fn(map[uint32]int(nil), (*encFnInfo).fastpathEncMapUint32IntR, (*decFnInfo).fastpathDecMapUint32IntR)
  232     fn(map[uint32]int8(nil), (*encFnInfo).fastpathEncMapUint32Int8R, (*decFnInfo).fastpathDecMapUint32Int8R)
  233     fn(map[uint32]int16(nil), (*encFnInfo).fastpathEncMapUint32Int16R, (*decFnInfo).fastpathDecMapUint32Int16R)
  234     fn(map[uint32]int32(nil), (*encFnInfo).fastpathEncMapUint32Int32R, (*decFnInfo).fastpathDecMapUint32Int32R)
  235     fn(map[uint32]int64(nil), (*encFnInfo).fastpathEncMapUint32Int64R, (*decFnInfo).fastpathDecMapUint32Int64R)
  236     fn(map[uint32]float32(nil), (*encFnInfo).fastpathEncMapUint32Float32R, (*decFnInfo).fastpathDecMapUint32Float32R)
  237     fn(map[uint32]float64(nil), (*encFnInfo).fastpathEncMapUint32Float64R, (*decFnInfo).fastpathDecMapUint32Float64R)
  238     fn(map[uint32]bool(nil), (*encFnInfo).fastpathEncMapUint32BoolR, (*decFnInfo).fastpathDecMapUint32BoolR)
  239     fn(map[uint64]interface{}(nil), (*encFnInfo).fastpathEncMapUint64IntfR, (*decFnInfo).fastpathDecMapUint64IntfR)
  240     fn(map[uint64]string(nil), (*encFnInfo).fastpathEncMapUint64StringR, (*decFnInfo).fastpathDecMapUint64StringR)
  241     fn(map[uint64]uint(nil), (*encFnInfo).fastpathEncMapUint64UintR, (*decFnInfo).fastpathDecMapUint64UintR)
  242     fn(map[uint64]uint8(nil), (*encFnInfo).fastpathEncMapUint64Uint8R, (*decFnInfo).fastpathDecMapUint64Uint8R)
  243     fn(map[uint64]uint16(nil), (*encFnInfo).fastpathEncMapUint64Uint16R, (*decFnInfo).fastpathDecMapUint64Uint16R)
  244     fn(map[uint64]uint32(nil), (*encFnInfo).fastpathEncMapUint64Uint32R, (*decFnInfo).fastpathDecMapUint64Uint32R)
  245     fn(map[uint64]uint64(nil), (*encFnInfo).fastpathEncMapUint64Uint64R, (*decFnInfo).fastpathDecMapUint64Uint64R)
  246     fn(map[uint64]uintptr(nil), (*encFnInfo).fastpathEncMapUint64UintptrR, (*decFnInfo).fastpathDecMapUint64UintptrR)
  247     fn(map[uint64]int(nil), (*encFnInfo).fastpathEncMapUint64IntR, (*decFnInfo).fastpathDecMapUint64IntR)
  248     fn(map[uint64]int8(nil), (*encFnInfo).fastpathEncMapUint64Int8R, (*decFnInfo).fastpathDecMapUint64Int8R)
  249     fn(map[uint64]int16(nil), (*encFnInfo).fastpathEncMapUint64Int16R, (*decFnInfo).fastpathDecMapUint64Int16R)
  250     fn(map[uint64]int32(nil), (*encFnInfo).fastpathEncMapUint64Int32R, (*decFnInfo).fastpathDecMapUint64Int32R)
  251     fn(map[uint64]int64(nil), (*encFnInfo).fastpathEncMapUint64Int64R, (*decFnInfo).fastpathDecMapUint64Int64R)
  252     fn(map[uint64]float32(nil), (*encFnInfo).fastpathEncMapUint64Float32R, (*decFnInfo).fastpathDecMapUint64Float32R)
  253     fn(map[uint64]float64(nil), (*encFnInfo).fastpathEncMapUint64Float64R, (*decFnInfo).fastpathDecMapUint64Float64R)
  254     fn(map[uint64]bool(nil), (*encFnInfo).fastpathEncMapUint64BoolR, (*decFnInfo).fastpathDecMapUint64BoolR)
  255     fn(map[uintptr]interface{}(nil), (*encFnInfo).fastpathEncMapUintptrIntfR, (*decFnInfo).fastpathDecMapUintptrIntfR)
  256     fn(map[uintptr]string(nil), (*encFnInfo).fastpathEncMapUintptrStringR, (*decFnInfo).fastpathDecMapUintptrStringR)
  257     fn(map[uintptr]uint(nil), (*encFnInfo).fastpathEncMapUintptrUintR, (*decFnInfo).fastpathDecMapUintptrUintR)
  258     fn(map[uintptr]uint8(nil), (*encFnInfo).fastpathEncMapUintptrUint8R, (*decFnInfo).fastpathDecMapUintptrUint8R)
  259     fn(map[uintptr]uint16(nil), (*encFnInfo).fastpathEncMapUintptrUint16R, (*decFnInfo).fastpathDecMapUintptrUint16R)
  260     fn(map[uintptr]uint32(nil), (*encFnInfo).fastpathEncMapUintptrUint32R, (*decFnInfo).fastpathDecMapUintptrUint32R)
  261     fn(map[uintptr]uint64(nil), (*encFnInfo).fastpathEncMapUintptrUint64R, (*decFnInfo).fastpathDecMapUintptrUint64R)
  262     fn(map[uintptr]uintptr(nil), (*encFnInfo).fastpathEncMapUintptrUintptrR, (*decFnInfo).fastpathDecMapUintptrUintptrR)
  263     fn(map[uintptr]int(nil), (*encFnInfo).fastpathEncMapUintptrIntR, (*decFnInfo).fastpathDecMapUintptrIntR)
  264     fn(map[uintptr]int8(nil), (*encFnInfo).fastpathEncMapUintptrInt8R, (*decFnInfo).fastpathDecMapUintptrInt8R)
  265     fn(map[uintptr]int16(nil), (*encFnInfo).fastpathEncMapUintptrInt16R, (*decFnInfo).fastpathDecMapUintptrInt16R)
  266     fn(map[uintptr]int32(nil), (*encFnInfo).fastpathEncMapUintptrInt32R, (*decFnInfo).fastpathDecMapUintptrInt32R)
  267     fn(map[uintptr]int64(nil), (*encFnInfo).fastpathEncMapUintptrInt64R, (*decFnInfo).fastpathDecMapUintptrInt64R)
  268     fn(map[uintptr]float32(nil), (*encFnInfo).fastpathEncMapUintptrFloat32R, (*decFnInfo).fastpathDecMapUintptrFloat32R)
  269     fn(map[uintptr]float64(nil), (*encFnInfo).fastpathEncMapUintptrFloat64R, (*decFnInfo).fastpathDecMapUintptrFloat64R)
  270     fn(map[uintptr]bool(nil), (*encFnInfo).fastpathEncMapUintptrBoolR, (*decFnInfo).fastpathDecMapUintptrBoolR)
  271     fn(map[int]interface{}(nil), (*encFnInfo).fastpathEncMapIntIntfR, (*decFnInfo).fastpathDecMapIntIntfR)
  272     fn(map[int]string(nil), (*encFnInfo).fastpathEncMapIntStringR, (*decFnInfo).fastpathDecMapIntStringR)
  273     fn(map[int]uint(nil), (*encFnInfo).fastpathEncMapIntUintR, (*decFnInfo).fastpathDecMapIntUintR)
  274     fn(map[int]uint8(nil), (*encFnInfo).fastpathEncMapIntUint8R, (*decFnInfo).fastpathDecMapIntUint8R)
  275     fn(map[int]uint16(nil), (*encFnInfo).fastpathEncMapIntUint16R, (*decFnInfo).fastpathDecMapIntUint16R)
  276     fn(map[int]uint32(nil), (*encFnInfo).fastpathEncMapIntUint32R, (*decFnInfo).fastpathDecMapIntUint32R)
  277     fn(map[int]uint64(nil), (*encFnInfo).fastpathEncMapIntUint64R, (*decFnInfo).fastpathDecMapIntUint64R)
  278     fn(map[int]uintptr(nil), (*encFnInfo).fastpathEncMapIntUintptrR, (*decFnInfo).fastpathDecMapIntUintptrR)
  279     fn(map[int]int(nil), (*encFnInfo).fastpathEncMapIntIntR, (*decFnInfo).fastpathDecMapIntIntR)
  280     fn(map[int]int8(nil), (*encFnInfo).fastpathEncMapIntInt8R, (*decFnInfo).fastpathDecMapIntInt8R)
  281     fn(map[int]int16(nil), (*encFnInfo).fastpathEncMapIntInt16R, (*decFnInfo).fastpathDecMapIntInt16R)
  282     fn(map[int]int32(nil), (*encFnInfo).fastpathEncMapIntInt32R, (*decFnInfo).fastpathDecMapIntInt32R)
  283     fn(map[int]int64(nil), (*encFnInfo).fastpathEncMapIntInt64R, (*decFnInfo).fastpathDecMapIntInt64R)
  284     fn(map[int]float32(nil), (*encFnInfo).fastpathEncMapIntFloat32R, (*decFnInfo).fastpathDecMapIntFloat32R)
  285     fn(map[int]float64(nil), (*encFnInfo).fastpathEncMapIntFloat64R, (*decFnInfo).fastpathDecMapIntFloat64R)
  286     fn(map[int]bool(nil), (*encFnInfo).fastpathEncMapIntBoolR, (*decFnInfo).fastpathDecMapIntBoolR)
  287     fn(map[int8]interface{}(nil), (*encFnInfo).fastpathEncMapInt8IntfR, (*decFnInfo).fastpathDecMapInt8IntfR)
  288     fn(map[int8]string(nil), (*encFnInfo).fastpathEncMapInt8StringR, (*decFnInfo).fastpathDecMapInt8StringR)
  289     fn(map[int8]uint(nil), (*encFnInfo).fastpathEncMapInt8UintR, (*decFnInfo).fastpathDecMapInt8UintR)
  290     fn(map[int8]uint8(nil), (*encFnInfo).fastpathEncMapInt8Uint8R, (*decFnInfo).fastpathDecMapInt8Uint8R)
  291     fn(map[int8]uint16(nil), (*encFnInfo).fastpathEncMapInt8Uint16R, (*decFnInfo).fastpathDecMapInt8Uint16R)
  292     fn(map[int8]uint32(nil), (*encFnInfo).fastpathEncMapInt8Uint32R, (*decFnInfo).fastpathDecMapInt8Uint32R)
  293     fn(map[int8]uint64(nil), (*encFnInfo).fastpathEncMapInt8Uint64R, (*decFnInfo).fastpathDecMapInt8Uint64R)
  294     fn(map[int8]uintptr(nil), (*encFnInfo).fastpathEncMapInt8UintptrR, (*decFnInfo).fastpathDecMapInt8UintptrR)
  295     fn(map[int8]int(nil), (*encFnInfo).fastpathEncMapInt8IntR, (*decFnInfo).fastpathDecMapInt8IntR)
  296     fn(map[int8]int8(nil), (*encFnInfo).fastpathEncMapInt8Int8R, (*decFnInfo).fastpathDecMapInt8Int8R)
  297     fn(map[int8]int16(nil), (*encFnInfo).fastpathEncMapInt8Int16R, (*decFnInfo).fastpathDecMapInt8Int16R)
  298     fn(map[int8]int32(nil), (*encFnInfo).fastpathEncMapInt8Int32R, (*decFnInfo).fastpathDecMapInt8Int32R)
  299     fn(map[int8]int64(nil), (*encFnInfo).fastpathEncMapInt8Int64R, (*decFnInfo).fastpathDecMapInt8Int64R)
  300     fn(map[int8]float32(nil), (*encFnInfo).fastpathEncMapInt8Float32R, (*decFnInfo).fastpathDecMapInt8Float32R)
  301     fn(map[int8]float64(nil), (*encFnInfo).fastpathEncMapInt8Float64R, (*decFnInfo).fastpathDecMapInt8Float64R)
  302     fn(map[int8]bool(nil), (*encFnInfo).fastpathEncMapInt8BoolR, (*decFnInfo).fastpathDecMapInt8BoolR)
  303     fn(map[int16]interface{}(nil), (*encFnInfo).fastpathEncMapInt16IntfR, (*decFnInfo).fastpathDecMapInt16IntfR)
  304     fn(map[int16]string(nil), (*encFnInfo).fastpathEncMapInt16StringR, (*decFnInfo).fastpathDecMapInt16StringR)
  305     fn(map[int16]uint(nil), (*encFnInfo).fastpathEncMapInt16UintR, (*decFnInfo).fastpathDecMapInt16UintR)
  306     fn(map[int16]uint8(nil), (*encFnInfo).fastpathEncMapInt16Uint8R, (*decFnInfo).fastpathDecMapInt16Uint8R)
  307     fn(map[int16]uint16(nil), (*encFnInfo).fastpathEncMapInt16Uint16R, (*decFnInfo).fastpathDecMapInt16Uint16R)
  308     fn(map[int16]uint32(nil), (*encFnInfo).fastpathEncMapInt16Uint32R, (*decFnInfo).fastpathDecMapInt16Uint32R)
  309     fn(map[int16]uint64(nil), (*encFnInfo).fastpathEncMapInt16Uint64R, (*decFnInfo).fastpathDecMapInt16Uint64R)
  310     fn(map[int16]uintptr(nil), (*encFnInfo).fastpathEncMapInt16UintptrR, (*decFnInfo).fastpathDecMapInt16UintptrR)
  311     fn(map[int16]int(nil), (*encFnInfo).fastpathEncMapInt16IntR, (*decFnInfo).fastpathDecMapInt16IntR)
  312     fn(map[int16]int8(nil), (*encFnInfo).fastpathEncMapInt16Int8R, (*decFnInfo).fastpathDecMapInt16Int8R)
  313     fn(map[int16]int16(nil), (*encFnInfo).fastpathEncMapInt16Int16R, (*decFnInfo).fastpathDecMapInt16Int16R)
  314     fn(map[int16]int32(nil), (*encFnInfo).fastpathEncMapInt16Int32R, (*decFnInfo).fastpathDecMapInt16Int32R)
  315     fn(map[int16]int64(nil), (*encFnInfo).fastpathEncMapInt16Int64R, (*decFnInfo).fastpathDecMapInt16Int64R)
  316     fn(map[int16]float32(nil), (*encFnInfo).fastpathEncMapInt16Float32R, (*decFnInfo).fastpathDecMapInt16Float32R)
  317     fn(map[int16]float64(nil), (*encFnInfo).fastpathEncMapInt16Float64R, (*decFnInfo).fastpathDecMapInt16Float64R)
  318     fn(map[int16]bool(nil), (*encFnInfo).fastpathEncMapInt16BoolR, (*decFnInfo).fastpathDecMapInt16BoolR)
  319     fn(map[int32]interface{}(nil), (*encFnInfo).fastpathEncMapInt32IntfR, (*decFnInfo).fastpathDecMapInt32IntfR)
  320     fn(map[int32]string(nil), (*encFnInfo).fastpathEncMapInt32StringR, (*decFnInfo).fastpathDecMapInt32StringR)
  321     fn(map[int32]uint(nil), (*encFnInfo).fastpathEncMapInt32UintR, (*decFnInfo).fastpathDecMapInt32UintR)
  322     fn(map[int32]uint8(nil), (*encFnInfo).fastpathEncMapInt32Uint8R, (*decFnInfo).fastpathDecMapInt32Uint8R)
  323     fn(map[int32]uint16(nil), (*encFnInfo).fastpathEncMapInt32Uint16R, (*decFnInfo).fastpathDecMapInt32Uint16R)
  324     fn(map[int32]uint32(nil), (*encFnInfo).fastpathEncMapInt32Uint32R, (*decFnInfo).fastpathDecMapInt32Uint32R)
  325     fn(map[int32]uint64(nil), (*encFnInfo).fastpathEncMapInt32Uint64R, (*decFnInfo).fastpathDecMapInt32Uint64R)
  326     fn(map[int32]uintptr(nil), (*encFnInfo).fastpathEncMapInt32UintptrR, (*decFnInfo).fastpathDecMapInt32UintptrR)
  327     fn(map[int32]int(nil), (*encFnInfo).fastpathEncMapInt32IntR, (*decFnInfo).fastpathDecMapInt32IntR)
  328     fn(map[int32]int8(nil), (*encFnInfo).fastpathEncMapInt32Int8R, (*decFnInfo).fastpathDecMapInt32Int8R)
  329     fn(map[int32]int16(nil), (*encFnInfo).fastpathEncMapInt32Int16R, (*decFnInfo).fastpathDecMapInt32Int16R)
  330     fn(map[int32]int32(nil), (*encFnInfo).fastpathEncMapInt32Int32R, (*decFnInfo).fastpathDecMapInt32Int32R)
  331     fn(map[int32]int64(nil), (*encFnInfo).fastpathEncMapInt32Int64R, (*decFnInfo).fastpathDecMapInt32Int64R)
  332     fn(map[int32]float32(nil), (*encFnInfo).fastpathEncMapInt32Float32R, (*decFnInfo).fastpathDecMapInt32Float32R)
  333     fn(map[int32]float64(nil), (*encFnInfo).fastpathEncMapInt32Float64R, (*decFnInfo).fastpathDecMapInt32Float64R)
  334     fn(map[int32]bool(nil), (*encFnInfo).fastpathEncMapInt32BoolR, (*decFnInfo).fastpathDecMapInt32BoolR)
  335     fn(map[int64]interface{}(nil), (*encFnInfo).fastpathEncMapInt64IntfR, (*decFnInfo).fastpathDecMapInt64IntfR)
  336     fn(map[int64]string(nil), (*encFnInfo).fastpathEncMapInt64StringR, (*decFnInfo).fastpathDecMapInt64StringR)
  337     fn(map[int64]uint(nil), (*encFnInfo).fastpathEncMapInt64UintR, (*decFnInfo).fastpathDecMapInt64UintR)
  338     fn(map[int64]uint8(nil), (*encFnInfo).fastpathEncMapInt64Uint8R, (*decFnInfo).fastpathDecMapInt64Uint8R)
  339     fn(map[int64]uint16(nil), (*encFnInfo).fastpathEncMapInt64Uint16R, (*decFnInfo).fastpathDecMapInt64Uint16R)
  340     fn(map[int64]uint32(nil), (*encFnInfo).fastpathEncMapInt64Uint32R, (*decFnInfo).fastpathDecMapInt64Uint32R)
  341     fn(map[int64]uint64(nil), (*encFnInfo).fastpathEncMapInt64Uint64R, (*decFnInfo).fastpathDecMapInt64Uint64R)
  342     fn(map[int64]uintptr(nil), (*encFnInfo).fastpathEncMapInt64UintptrR, (*decFnInfo).fastpathDecMapInt64UintptrR)
  343     fn(map[int64]int(nil), (*encFnInfo).fastpathEncMapInt64IntR, (*decFnInfo).fastpathDecMapInt64IntR)
  344     fn(map[int64]int8(nil), (*encFnInfo).fastpathEncMapInt64Int8R, (*decFnInfo).fastpathDecMapInt64Int8R)
  345     fn(map[int64]int16(nil), (*encFnInfo).fastpathEncMapInt64Int16R, (*decFnInfo).fastpathDecMapInt64Int16R)
  346     fn(map[int64]int32(nil), (*encFnInfo).fastpathEncMapInt64Int32R, (*decFnInfo).fastpathDecMapInt64Int32R)
  347     fn(map[int64]int64(nil), (*encFnInfo).fastpathEncMapInt64Int64R, (*decFnInfo).fastpathDecMapInt64Int64R)
  348     fn(map[int64]float32(nil), (*encFnInfo).fastpathEncMapInt64Float32R, (*decFnInfo).fastpathDecMapInt64Float32R)
  349     fn(map[int64]float64(nil), (*encFnInfo).fastpathEncMapInt64Float64R, (*decFnInfo).fastpathDecMapInt64Float64R)
  350     fn(map[int64]bool(nil), (*encFnInfo).fastpathEncMapInt64BoolR, (*decFnInfo).fastpathDecMapInt64BoolR)
  351     fn(map[bool]interface{}(nil), (*encFnInfo).fastpathEncMapBoolIntfR, (*decFnInfo).fastpathDecMapBoolIntfR)
  352     fn(map[bool]string(nil), (*encFnInfo).fastpathEncMapBoolStringR, (*decFnInfo).fastpathDecMapBoolStringR)
  353     fn(map[bool]uint(nil), (*encFnInfo).fastpathEncMapBoolUintR, (*decFnInfo).fastpathDecMapBoolUintR)
  354     fn(map[bool]uint8(nil), (*encFnInfo).fastpathEncMapBoolUint8R, (*decFnInfo).fastpathDecMapBoolUint8R)
  355     fn(map[bool]uint16(nil), (*encFnInfo).fastpathEncMapBoolUint16R, (*decFnInfo).fastpathDecMapBoolUint16R)
  356     fn(map[bool]uint32(nil), (*encFnInfo).fastpathEncMapBoolUint32R, (*decFnInfo).fastpathDecMapBoolUint32R)
  357     fn(map[bool]uint64(nil), (*encFnInfo).fastpathEncMapBoolUint64R, (*decFnInfo).fastpathDecMapBoolUint64R)
  358     fn(map[bool]uintptr(nil), (*encFnInfo).fastpathEncMapBoolUintptrR, (*decFnInfo).fastpathDecMapBoolUintptrR)
  359     fn(map[bool]int(nil), (*encFnInfo).fastpathEncMapBoolIntR, (*decFnInfo).fastpathDecMapBoolIntR)
  360     fn(map[bool]int8(nil), (*encFnInfo).fastpathEncMapBoolInt8R, (*decFnInfo).fastpathDecMapBoolInt8R)
  361     fn(map[bool]int16(nil), (*encFnInfo).fastpathEncMapBoolInt16R, (*decFnInfo).fastpathDecMapBoolInt16R)
  362     fn(map[bool]int32(nil), (*encFnInfo).fastpathEncMapBoolInt32R, (*decFnInfo).fastpathDecMapBoolInt32R)
  363     fn(map[bool]int64(nil), (*encFnInfo).fastpathEncMapBoolInt64R, (*decFnInfo).fastpathDecMapBoolInt64R)
  364     fn(map[bool]float32(nil), (*encFnInfo).fastpathEncMapBoolFloat32R, (*decFnInfo).fastpathDecMapBoolFloat32R)
  365     fn(map[bool]float64(nil), (*encFnInfo).fastpathEncMapBoolFloat64R, (*decFnInfo).fastpathDecMapBoolFloat64R)
  366     fn(map[bool]bool(nil), (*encFnInfo).fastpathEncMapBoolBoolR, (*decFnInfo).fastpathDecMapBoolBoolR)
  367 
  368     sort.Sort(fastpathAslice(fastpathAV[:]))
  369 }
  370 
  371 // -- encode
  372 
  373 // -- -- fast path type switch
  374 func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool {
  375     switch v := iv.(type) {
  376 
  377     case []interface{}:
  378         fastpathTV.EncSliceIntfV(v, fastpathCheckNilTrue, e)
  379     case *[]interface{}:
  380         fastpathTV.EncSliceIntfV(*v, fastpathCheckNilTrue, e)
  381 
  382     case map[interface{}]interface{}:
  383         fastpathTV.EncMapIntfIntfV(v, fastpathCheckNilTrue, e)
  384     case *map[interface{}]interface{}:
  385         fastpathTV.EncMapIntfIntfV(*v, fastpathCheckNilTrue, e)
  386 
  387     case map[interface{}]string:
  388         fastpathTV.EncMapIntfStringV(v, fastpathCheckNilTrue, e)
  389     case *map[interface{}]string:
  390         fastpathTV.EncMapIntfStringV(*v, fastpathCheckNilTrue, e)
  391 
  392     case map[interface{}]uint:
  393         fastpathTV.EncMapIntfUintV(v, fastpathCheckNilTrue, e)
  394     case *map[interface{}]uint:
  395         fastpathTV.EncMapIntfUintV(*v, fastpathCheckNilTrue, e)
  396 
  397     case map[interface{}]uint8:
  398         fastpathTV.EncMapIntfUint8V(v, fastpathCheckNilTrue, e)
  399     case *map[interface{}]uint8:
  400         fastpathTV.EncMapIntfUint8V(*v, fastpathCheckNilTrue, e)
  401 
  402     case map[interface{}]uint16:
  403         fastpathTV.EncMapIntfUint16V(v, fastpathCheckNilTrue, e)
  404     case *map[interface{}]uint16:
  405         fastpathTV.EncMapIntfUint16V(*v, fastpathCheckNilTrue, e)
  406 
  407     case map[interface{}]uint32:
  408         fastpathTV.EncMapIntfUint32V(v, fastpathCheckNilTrue, e)
  409     case *map[interface{}]uint32:
  410         fastpathTV.EncMapIntfUint32V(*v, fastpathCheckNilTrue, e)
  411 
  412     case map[interface{}]uint64:
  413         fastpathTV.EncMapIntfUint64V(v, fastpathCheckNilTrue, e)
  414     case *map[interface{}]uint64:
  415         fastpathTV.EncMapIntfUint64V(*v, fastpathCheckNilTrue, e)
  416 
  417     case map[interface{}]uintptr:
  418         fastpathTV.EncMapIntfUintptrV(v, fastpathCheckNilTrue, e)
  419     case *map[interface{}]uintptr:
  420         fastpathTV.EncMapIntfUintptrV(*v, fastpathCheckNilTrue, e)
  421 
  422     case map[interface{}]int:
  423         fastpathTV.EncMapIntfIntV(v, fastpathCheckNilTrue, e)
  424     case *map[interface{}]int:
  425         fastpathTV.EncMapIntfIntV(*v, fastpathCheckNilTrue, e)
  426 
  427     case map[interface{}]int8:
  428         fastpathTV.EncMapIntfInt8V(v, fastpathCheckNilTrue, e)
  429     case *map[interface{}]int8:
  430         fastpathTV.EncMapIntfInt8V(*v, fastpathCheckNilTrue, e)
  431 
  432     case map[interface{}]int16:
  433         fastpathTV.EncMapIntfInt16V(v, fastpathCheckNilTrue, e)
  434     case *map[interface{}]int16:
  435         fastpathTV.EncMapIntfInt16V(*v, fastpathCheckNilTrue, e)
  436 
  437     case map[interface{}]int32:
  438         fastpathTV.EncMapIntfInt32V(v, fastpathCheckNilTrue, e)
  439     case *map[interface{}]int32:
  440         fastpathTV.EncMapIntfInt32V(*v, fastpathCheckNilTrue, e)
  441 
  442     case map[interface{}]int64:
  443         fastpathTV.EncMapIntfInt64V(v, fastpathCheckNilTrue, e)
  444     case *map[interface{}]int64:
  445         fastpathTV.EncMapIntfInt64V(*v, fastpathCheckNilTrue, e)
  446 
  447     case map[interface{}]float32:
  448         fastpathTV.EncMapIntfFloat32V(v, fastpathCheckNilTrue, e)
  449     case *map[interface{}]float32:
  450         fastpathTV.EncMapIntfFloat32V(*v, fastpathCheckNilTrue, e)
  451 
  452     case map[interface{}]float64:
  453         fastpathTV.EncMapIntfFloat64V(v, fastpathCheckNilTrue, e)
  454     case *map[interface{}]float64:
  455         fastpathTV.EncMapIntfFloat64V(*v, fastpathCheckNilTrue, e)
  456 
  457     case map[interface{}]bool:
  458         fastpathTV.EncMapIntfBoolV(v, fastpathCheckNilTrue, e)
  459     case *map[interface{}]bool:
  460         fastpathTV.EncMapIntfBoolV(*v, fastpathCheckNilTrue, e)
  461 
  462     case []string:
  463         fastpathTV.EncSliceStringV(v, fastpathCheckNilTrue, e)
  464     case *[]string:
  465         fastpathTV.EncSliceStringV(*v, fastpathCheckNilTrue, e)
  466 
  467     case map[string]interface{}:
  468         fastpathTV.EncMapStringIntfV(v, fastpathCheckNilTrue, e)
  469     case *map[string]interface{}:
  470         fastpathTV.EncMapStringIntfV(*v, fastpathCheckNilTrue, e)
  471 
  472     case map[string]string:
  473         fastpathTV.EncMapStringStringV(v, fastpathCheckNilTrue, e)
  474     case *map[string]string:
  475         fastpathTV.EncMapStringStringV(*v, fastpathCheckNilTrue, e)
  476 
  477     case map[string]uint:
  478         fastpathTV.EncMapStringUintV(v, fastpathCheckNilTrue, e)
  479     case *map[string]uint:
  480         fastpathTV.EncMapStringUintV(*v, fastpathCheckNilTrue, e)
  481 
  482     case map[string]uint8:
  483         fastpathTV.EncMapStringUint8V(v, fastpathCheckNilTrue, e)
  484     case *map[string]uint8:
  485         fastpathTV.EncMapStringUint8V(*v, fastpathCheckNilTrue, e)
  486 
  487     case map[string]uint16:
  488         fastpathTV.EncMapStringUint16V(v, fastpathCheckNilTrue, e)
  489     case *map[string]uint16:
  490         fastpathTV.EncMapStringUint16V(*v, fastpathCheckNilTrue, e)
  491 
  492     case map[string]uint32:
  493         fastpathTV.EncMapStringUint32V(v, fastpathCheckNilTrue, e)
  494     case *map[string]uint32:
  495         fastpathTV.EncMapStringUint32V(*v, fastpathCheckNilTrue, e)
  496 
  497     case map[string]uint64:
  498         fastpathTV.EncMapStringUint64V(v, fastpathCheckNilTrue, e)
  499     case *map[string]uint64:
  500         fastpathTV.EncMapStringUint64V(*v, fastpathCheckNilTrue, e)
  501 
  502     case map[string]uintptr:
  503         fastpathTV.EncMapStringUintptrV(v, fastpathCheckNilTrue, e)
  504     case *map[string]uintptr:
  505         fastpathTV.EncMapStringUintptrV(*v, fastpathCheckNilTrue, e)
  506 
  507     case map[string]int:
  508         fastpathTV.EncMapStringIntV(v, fastpathCheckNilTrue, e)
  509     case *map[string]int:
  510         fastpathTV.EncMapStringIntV(*v, fastpathCheckNilTrue, e)
  511 
  512     case map[string]int8:
  513         fastpathTV.EncMapStringInt8V(v, fastpathCheckNilTrue, e)
  514     case *map[string]int8:
  515         fastpathTV.EncMapStringInt8V(*v, fastpathCheckNilTrue, e)
  516 
  517     case map[string]int16:
  518         fastpathTV.EncMapStringInt16V(v, fastpathCheckNilTrue, e)
  519     case *map[string]int16:
  520         fastpathTV.EncMapStringInt16V(*v, fastpathCheckNilTrue, e)
  521 
  522     case map[string]int32:
  523         fastpathTV.EncMapStringInt32V(v, fastpathCheckNilTrue, e)
  524     case *map[string]int32:
  525         fastpathTV.EncMapStringInt32V(*v, fastpathCheckNilTrue, e)
  526 
  527     case map[string]int64:
  528         fastpathTV.EncMapStringInt64V(v, fastpathCheckNilTrue, e)
  529     case *map[string]int64:
  530         fastpathTV.EncMapStringInt64V(*v, fastpathCheckNilTrue, e)
  531 
  532     case map[string]float32:
  533         fastpathTV.EncMapStringFloat32V(v, fastpathCheckNilTrue, e)
  534     case *map[string]float32:
  535         fastpathTV.EncMapStringFloat32V(*v, fastpathCheckNilTrue, e)
  536 
  537     case map[string]float64:
  538         fastpathTV.EncMapStringFloat64V(v, fastpathCheckNilTrue, e)
  539     case *map[string]float64:
  540         fastpathTV.EncMapStringFloat64V(*v, fastpathCheckNilTrue, e)
  541 
  542     case map[string]bool:
  543         fastpathTV.EncMapStringBoolV(v, fastpathCheckNilTrue, e)
  544     case *map[string]bool:
  545         fastpathTV.EncMapStringBoolV(*v, fastpathCheckNilTrue, e)
  546 
  547     case []float32:
  548         fastpathTV.EncSliceFloat32V(v, fastpathCheckNilTrue, e)
  549     case *[]float32:
  550         fastpathTV.EncSliceFloat32V(*v, fastpathCheckNilTrue, e)
  551 
  552     case map[float32]interface{}:
  553         fastpathTV.EncMapFloat32IntfV(v, fastpathCheckNilTrue, e)
  554     case *map[float32]interface{}:
  555         fastpathTV.EncMapFloat32IntfV(*v, fastpathCheckNilTrue, e)
  556 
  557     case map[float32]string:
  558         fastpathTV.EncMapFloat32StringV(v, fastpathCheckNilTrue, e)
  559     case *map[float32]string:
  560         fastpathTV.EncMapFloat32StringV(*v, fastpathCheckNilTrue, e)
  561 
  562     case map[float32]uint:
  563         fastpathTV.EncMapFloat32UintV(v, fastpathCheckNilTrue, e)
  564     case *map[float32]uint:
  565         fastpathTV.EncMapFloat32UintV(*v, fastpathCheckNilTrue, e)
  566 
  567     case map[float32]uint8:
  568         fastpathTV.EncMapFloat32Uint8V(v, fastpathCheckNilTrue, e)
  569     case *map[float32]uint8:
  570         fastpathTV.EncMapFloat32Uint8V(*v, fastpathCheckNilTrue, e)
  571 
  572     case map[float32]uint16:
  573         fastpathTV.EncMapFloat32Uint16V(v, fastpathCheckNilTrue, e)
  574     case *map[float32]uint16:
  575         fastpathTV.EncMapFloat32Uint16V(*v, fastpathCheckNilTrue, e)
  576 
  577     case map[float32]uint32:
  578         fastpathTV.EncMapFloat32Uint32V(v, fastpathCheckNilTrue, e)
  579     case *map[float32]uint32:
  580         fastpathTV.EncMapFloat32Uint32V(*v, fastpathCheckNilTrue, e)
  581 
  582     case map[float32]uint64:
  583         fastpathTV.EncMapFloat32Uint64V(v, fastpathCheckNilTrue, e)
  584     case *map[float32]uint64:
  585         fastpathTV.EncMapFloat32Uint64V(*v, fastpathCheckNilTrue, e)
  586 
  587     case map[float32]uintptr:
  588         fastpathTV.EncMapFloat32UintptrV(v, fastpathCheckNilTrue, e)
  589     case *map[float32]uintptr:
  590         fastpathTV.EncMapFloat32UintptrV(*v, fastpathCheckNilTrue, e)
  591 
  592     case map[float32]int:
  593         fastpathTV.EncMapFloat32IntV(v, fastpathCheckNilTrue, e)
  594     case *map[float32]int:
  595         fastpathTV.EncMapFloat32IntV(*v, fastpathCheckNilTrue, e)
  596 
  597     case map[float32]int8:
  598         fastpathTV.EncMapFloat32Int8V(v, fastpathCheckNilTrue, e)
  599     case *map[float32]int8:
  600         fastpathTV.EncMapFloat32Int8V(*v, fastpathCheckNilTrue, e)
  601 
  602     case map[float32]int16:
  603         fastpathTV.EncMapFloat32Int16V(v, fastpathCheckNilTrue, e)
  604     case *map[float32]int16:
  605         fastpathTV.EncMapFloat32Int16V(*v, fastpathCheckNilTrue, e)
  606 
  607     case map[float32]int32:
  608         fastpathTV.EncMapFloat32Int32V(v, fastpathCheckNilTrue, e)
  609     case *map[float32]int32:
  610         fastpathTV.EncMapFloat32Int32V(*v, fastpathCheckNilTrue, e)
  611 
  612     case map[float32]int64:
  613         fastpathTV.EncMapFloat32Int64V(v, fastpathCheckNilTrue, e)
  614     case *map[float32]int64:
  615         fastpathTV.EncMapFloat32Int64V(*v, fastpathCheckNilTrue, e)
  616 
  617     case map[float32]float32:
  618         fastpathTV.EncMapFloat32Float32V(v, fastpathCheckNilTrue, e)
  619     case *map[float32]float32:
  620         fastpathTV.EncMapFloat32Float32V(*v, fastpathCheckNilTrue, e)
  621 
  622     case map[float32]float64:
  623         fastpathTV.EncMapFloat32Float64V(v, fastpathCheckNilTrue, e)
  624     case *map[float32]float64:
  625         fastpathTV.EncMapFloat32Float64V(*v, fastpathCheckNilTrue, e)
  626 
  627     case map[float32]bool:
  628         fastpathTV.EncMapFloat32BoolV(v, fastpathCheckNilTrue, e)
  629     case *map[float32]bool:
  630         fastpathTV.EncMapFloat32BoolV(*v, fastpathCheckNilTrue, e)
  631 
  632     case []float64:
  633         fastpathTV.EncSliceFloat64V(v, fastpathCheckNilTrue, e)
  634     case *[]float64:
  635         fastpathTV.EncSliceFloat64V(*v, fastpathCheckNilTrue, e)
  636 
  637     case map[float64]interface{}:
  638         fastpathTV.EncMapFloat64IntfV(v, fastpathCheckNilTrue, e)
  639     case *map[float64]interface{}:
  640         fastpathTV.EncMapFloat64IntfV(*v, fastpathCheckNilTrue, e)
  641 
  642     case map[float64]string:
  643         fastpathTV.EncMapFloat64StringV(v, fastpathCheckNilTrue, e)
  644     case *map[float64]string:
  645         fastpathTV.EncMapFloat64StringV(*v, fastpathCheckNilTrue, e)
  646 
  647     case map[float64]uint:
  648         fastpathTV.EncMapFloat64UintV(v, fastpathCheckNilTrue, e)
  649     case *map[float64]uint:
  650         fastpathTV.EncMapFloat64UintV(*v, fastpathCheckNilTrue, e)
  651 
  652     case map[float64]uint8:
  653         fastpathTV.EncMapFloat64Uint8V(v, fastpathCheckNilTrue, e)
  654     case *map[float64]uint8:
  655         fastpathTV.EncMapFloat64Uint8V(*v, fastpathCheckNilTrue, e)
  656 
  657     case map[float64]uint16:
  658         fastpathTV.EncMapFloat64Uint16V(v, fastpathCheckNilTrue, e)
  659     case *map[float64]uint16:
  660         fastpathTV.EncMapFloat64Uint16V(*v, fastpathCheckNilTrue, e)
  661 
  662     case map[float64]uint32:
  663         fastpathTV.EncMapFloat64Uint32V(v, fastpathCheckNilTrue, e)
  664     case *map[float64]uint32:
  665         fastpathTV.EncMapFloat64Uint32V(*v, fastpathCheckNilTrue, e)
  666 
  667     case map[float64]uint64:
  668         fastpathTV.EncMapFloat64Uint64V(v, fastpathCheckNilTrue, e)
  669     case *map[float64]uint64:
  670         fastpathTV.EncMapFloat64Uint64V(*v, fastpathCheckNilTrue, e)
  671 
  672     case map[float64]uintptr:
  673         fastpathTV.EncMapFloat64UintptrV(v, fastpathCheckNilTrue, e)
  674     case *map[float64]uintptr:
  675         fastpathTV.EncMapFloat64UintptrV(*v, fastpathCheckNilTrue, e)
  676 
  677     case map[float64]int:
  678         fastpathTV.EncMapFloat64IntV(v, fastpathCheckNilTrue, e)
  679     case *map[float64]int:
  680         fastpathTV.EncMapFloat64IntV(*v, fastpathCheckNilTrue, e)
  681 
  682     case map[float64]int8:
  683         fastpathTV.EncMapFloat64Int8V(v, fastpathCheckNilTrue, e)
  684     case *map[float64]int8:
  685         fastpathTV.EncMapFloat64Int8V(*v, fastpathCheckNilTrue, e)
  686 
  687     case map[float64]int16:
  688         fastpathTV.EncMapFloat64Int16V(v, fastpathCheckNilTrue, e)
  689     case *map[float64]int16:
  690         fastpathTV.EncMapFloat64Int16V(*v, fastpathCheckNilTrue, e)
  691 
  692     case map[float64]int32:
  693         fastpathTV.EncMapFloat64Int32V(v, fastpathCheckNilTrue, e)
  694     case *map[float64]int32:
  695         fastpathTV.EncMapFloat64Int32V(*v, fastpathCheckNilTrue, e)
  696 
  697     case map[float64]int64:
  698         fastpathTV.EncMapFloat64Int64V(v, fastpathCheckNilTrue, e)
  699     case *map[float64]int64:
  700         fastpathTV.EncMapFloat64Int64V(*v, fastpathCheckNilTrue, e)
  701 
  702     case map[float64]float32:
  703         fastpathTV.EncMapFloat64Float32V(v, fastpathCheckNilTrue, e)
  704     case *map[float64]float32:
  705         fastpathTV.EncMapFloat64Float32V(*v, fastpathCheckNilTrue, e)
  706 
  707     case map[float64]float64:
  708         fastpathTV.EncMapFloat64Float64V(v, fastpathCheckNilTrue, e)
  709     case *map[float64]float64:
  710         fastpathTV.EncMapFloat64Float64V(*v, fastpathCheckNilTrue, e)
  711 
  712     case map[float64]bool:
  713         fastpathTV.EncMapFloat64BoolV(v, fastpathCheckNilTrue, e)
  714     case *map[float64]bool:
  715         fastpathTV.EncMapFloat64BoolV(*v, fastpathCheckNilTrue, e)
  716 
  717     case []uint:
  718         fastpathTV.EncSliceUintV(v, fastpathCheckNilTrue, e)
  719     case *[]uint:
  720         fastpathTV.EncSliceUintV(*v, fastpathCheckNilTrue, e)
  721 
  722     case map[uint]interface{}:
  723         fastpathTV.EncMapUintIntfV(v, fastpathCheckNilTrue, e)
  724     case *map[uint]interface{}:
  725         fastpathTV.EncMapUintIntfV(*v, fastpathCheckNilTrue, e)
  726 
  727     case map[uint]string:
  728         fastpathTV.EncMapUintStringV(v, fastpathCheckNilTrue, e)
  729     case *map[uint]string:
  730         fastpathTV.EncMapUintStringV(*v, fastpathCheckNilTrue, e)
  731 
  732     case map[uint]uint:
  733         fastpathTV.EncMapUintUintV(v, fastpathCheckNilTrue, e)
  734     case *map[uint]uint:
  735         fastpathTV.EncMapUintUintV(*v, fastpathCheckNilTrue, e)
  736 
  737     case map[uint]uint8:
  738         fastpathTV.EncMapUintUint8V(v, fastpathCheckNilTrue, e)
  739     case *map[uint]uint8:
  740         fastpathTV.EncMapUintUint8V(*v, fastpathCheckNilTrue, e)
  741 
  742     case map[uint]uint16:
  743         fastpathTV.EncMapUintUint16V(v, fastpathCheckNilTrue, e)
  744     case *map[uint]uint16:
  745         fastpathTV.EncMapUintUint16V(*v, fastpathCheckNilTrue, e)
  746 
  747     case map[uint]uint32:
  748         fastpathTV.EncMapUintUint32V(v, fastpathCheckNilTrue, e)
  749     case *map[uint]uint32:
  750         fastpathTV.EncMapUintUint32V(*v, fastpathCheckNilTrue, e)
  751 
  752     case map[uint]uint64:
  753         fastpathTV.EncMapUintUint64V(v, fastpathCheckNilTrue, e)
  754     case *map[uint]uint64:
  755         fastpathTV.EncMapUintUint64V(*v, fastpathCheckNilTrue, e)
  756 
  757     case map[uint]uintptr:
  758         fastpathTV.EncMapUintUintptrV(v, fastpathCheckNilTrue, e)
  759     case *map[uint]uintptr:
  760         fastpathTV.EncMapUintUintptrV(*v, fastpathCheckNilTrue, e)
  761 
  762     case map[uint]int:
  763         fastpathTV.EncMapUintIntV(v, fastpathCheckNilTrue, e)
  764     case *map[uint]int:
  765         fastpathTV.EncMapUintIntV(*v, fastpathCheckNilTrue, e)
  766 
  767     case map[uint]int8:
  768         fastpathTV.EncMapUintInt8V(v, fastpathCheckNilTrue, e)
  769     case *map[uint]int8:
  770         fastpathTV.EncMapUintInt8V(*v, fastpathCheckNilTrue, e)
  771 
  772     case map[uint]int16:
  773         fastpathTV.EncMapUintInt16V(v, fastpathCheckNilTrue, e)
  774     case *map[uint]int16:
  775         fastpathTV.EncMapUintInt16V(*v, fastpathCheckNilTrue, e)
  776 
  777     case map[uint]int32:
  778         fastpathTV.EncMapUintInt32V(v, fastpathCheckNilTrue, e)
  779     case *map[uint]int32:
  780         fastpathTV.EncMapUintInt32V(*v, fastpathCheckNilTrue, e)
  781 
  782     case map[uint]int64:
  783         fastpathTV.EncMapUintInt64V(v, fastpathCheckNilTrue, e)
  784     case *map[uint]int64:
  785         fastpathTV.EncMapUintInt64V(*v, fastpathCheckNilTrue, e)
  786 
  787     case map[uint]float32:
  788         fastpathTV.EncMapUintFloat32V(v, fastpathCheckNilTrue, e)
  789     case *map[uint]float32:
  790         fastpathTV.EncMapUintFloat32V(*v, fastpathCheckNilTrue, e)
  791 
  792     case map[uint]float64:
  793         fastpathTV.EncMapUintFloat64V(v, fastpathCheckNilTrue, e)
  794     case *map[uint]float64:
  795         fastpathTV.EncMapUintFloat64V(*v, fastpathCheckNilTrue, e)
  796 
  797     case map[uint]bool:
  798         fastpathTV.EncMapUintBoolV(v, fastpathCheckNilTrue, e)
  799     case *map[uint]bool:
  800         fastpathTV.EncMapUintBoolV(*v, fastpathCheckNilTrue, e)
  801 
  802     case map[uint8]interface{}:
  803         fastpathTV.EncMapUint8IntfV(v, fastpathCheckNilTrue, e)
  804     case *map[uint8]interface{}:
  805         fastpathTV.EncMapUint8IntfV(*v, fastpathCheckNilTrue, e)
  806 
  807     case map[uint8]string:
  808         fastpathTV.EncMapUint8StringV(v, fastpathCheckNilTrue, e)
  809     case *map[uint8]string:
  810         fastpathTV.EncMapUint8StringV(*v, fastpathCheckNilTrue, e)
  811 
  812     case map[uint8]uint:
  813         fastpathTV.EncMapUint8UintV(v, fastpathCheckNilTrue, e)
  814     case *map[uint8]uint:
  815         fastpathTV.EncMapUint8UintV(*v, fastpathCheckNilTrue, e)
  816 
  817     case map[uint8]uint8:
  818         fastpathTV.EncMapUint8Uint8V(v, fastpathCheckNilTrue, e)
  819     case *map[uint8]uint8:
  820         fastpathTV.EncMapUint8Uint8V(*v, fastpathCheckNilTrue, e)
  821 
  822     case map[uint8]uint16:
  823         fastpathTV.EncMapUint8Uint16V(v, fastpathCheckNilTrue, e)
  824     case *map[uint8]uint16:
  825         fastpathTV.EncMapUint8Uint16V(*v, fastpathCheckNilTrue, e)
  826 
  827     case map[uint8]uint32:
  828         fastpathTV.EncMapUint8Uint32V(v, fastpathCheckNilTrue, e)
  829     case *map[uint8]uint32:
  830         fastpathTV.EncMapUint8Uint32V(*v, fastpathCheckNilTrue, e)
  831 
  832     case map[uint8]uint64:
  833         fastpathTV.EncMapUint8Uint64V(v, fastpathCheckNilTrue, e)
  834     case *map[uint8]uint64:
  835         fastpathTV.EncMapUint8Uint64V(*v, fastpathCheckNilTrue, e)
  836 
  837     case map[uint8]uintptr:
  838         fastpathTV.EncMapUint8UintptrV(v, fastpathCheckNilTrue, e)
  839     case *map[uint8]uintptr:
  840         fastpathTV.EncMapUint8UintptrV(*v, fastpathCheckNilTrue, e)
  841 
  842     case map[uint8]int:
  843         fastpathTV.EncMapUint8IntV(v, fastpathCheckNilTrue, e)
  844     case *map[uint8]int:
  845         fastpathTV.EncMapUint8IntV(*v, fastpathCheckNilTrue, e)
  846 
  847     case map[uint8]int8:
  848         fastpathTV.EncMapUint8Int8V(v, fastpathCheckNilTrue, e)
  849     case *map[uint8]int8:
  850         fastpathTV.EncMapUint8Int8V(*v, fastpathCheckNilTrue, e)
  851 
  852     case map[uint8]int16:
  853         fastpathTV.EncMapUint8Int16V(v, fastpathCheckNilTrue, e)
  854     case *map[uint8]int16:
  855         fastpathTV.EncMapUint8Int16V(*v, fastpathCheckNilTrue, e)
  856 
  857     case map[uint8]int32:
  858         fastpathTV.EncMapUint8Int32V(v, fastpathCheckNilTrue, e)
  859     case *map[uint8]int32:
  860         fastpathTV.EncMapUint8Int32V(*v, fastpathCheckNilTrue, e)
  861 
  862     case map[uint8]int64:
  863         fastpathTV.EncMapUint8Int64V(v, fastpathCheckNilTrue, e)
  864     case *map[uint8]int64:
  865         fastpathTV.EncMapUint8Int64V(*v, fastpathCheckNilTrue, e)
  866 
  867     case map[uint8]float32:
  868         fastpathTV.EncMapUint8Float32V(v, fastpathCheckNilTrue, e)
  869     case *map[uint8]float32:
  870         fastpathTV.EncMapUint8Float32V(*v, fastpathCheckNilTrue, e)
  871 
  872     case map[uint8]float64:
  873         fastpathTV.EncMapUint8Float64V(v, fastpathCheckNilTrue, e)
  874     case *map[uint8]float64:
  875         fastpathTV.EncMapUint8Float64V(*v, fastpathCheckNilTrue, e)
  876 
  877     case map[uint8]bool:
  878         fastpathTV.EncMapUint8BoolV(v, fastpathCheckNilTrue, e)
  879     case *map[uint8]bool:
  880         fastpathTV.EncMapUint8BoolV(*v, fastpathCheckNilTrue, e)
  881 
  882     case []uint16:
  883         fastpathTV.EncSliceUint16V(v, fastpathCheckNilTrue, e)
  884     case *[]uint16:
  885         fastpathTV.EncSliceUint16V(*v, fastpathCheckNilTrue, e)
  886 
  887     case map[uint16]interface{}:
  888         fastpathTV.EncMapUint16IntfV(v, fastpathCheckNilTrue, e)
  889     case *map[uint16]interface{}:
  890         fastpathTV.EncMapUint16IntfV(*v, fastpathCheckNilTrue, e)
  891 
  892     case map[uint16]string:
  893         fastpathTV.EncMapUint16StringV(v, fastpathCheckNilTrue, e)
  894     case *map[uint16]string:
  895         fastpathTV.EncMapUint16StringV(*v, fastpathCheckNilTrue, e)
  896 
  897     case map[uint16]uint:
  898         fastpathTV.EncMapUint16UintV(v, fastpathCheckNilTrue, e)
  899     case *map[uint16]uint:
  900         fastpathTV.EncMapUint16UintV(*v, fastpathCheckNilTrue, e)
  901 
  902     case map[uint16]uint8:
  903         fastpathTV.EncMapUint16Uint8V(v, fastpathCheckNilTrue, e)
  904     case *map[uint16]uint8:
  905         fastpathTV.EncMapUint16Uint8V(*v, fastpathCheckNilTrue, e)
  906 
  907     case map[uint16]uint16:
  908         fastpathTV.EncMapUint16Uint16V(v, fastpathCheckNilTrue, e)
  909     case *map[uint16]uint16:
  910         fastpathTV.EncMapUint16Uint16V(*v, fastpathCheckNilTrue, e)
  911 
  912     case map[uint16]uint32:
  913         fastpathTV.EncMapUint16Uint32V(v, fastpathCheckNilTrue, e)
  914     case *map[uint16]uint32:
  915         fastpathTV.EncMapUint16Uint32V(*v, fastpathCheckNilTrue, e)
  916 
  917     case map[uint16]uint64:
  918         fastpathTV.EncMapUint16Uint64V(v, fastpathCheckNilTrue, e)
  919     case *map[uint16]uint64:
  920         fastpathTV.EncMapUint16Uint64V(*v, fastpathCheckNilTrue, e)
  921 
  922     case map[uint16]uintptr:
  923         fastpathTV.EncMapUint16UintptrV(v, fastpathCheckNilTrue, e)
  924     case *map[uint16]uintptr:
  925         fastpathTV.EncMapUint16UintptrV(*v, fastpathCheckNilTrue, e)
  926 
  927     case map[uint16]int:
  928         fastpathTV.EncMapUint16IntV(v, fastpathCheckNilTrue, e)
  929     case *map[uint16]int:
  930         fastpathTV.EncMapUint16IntV(*v, fastpathCheckNilTrue, e)
  931 
  932     case map[uint16]int8:
  933         fastpathTV.EncMapUint16Int8V(v, fastpathCheckNilTrue, e)
  934     case *map[uint16]int8:
  935         fastpathTV.EncMapUint16Int8V(*v, fastpathCheckNilTrue, e)
  936 
  937     case map[uint16]int16:
  938         fastpathTV.EncMapUint16Int16V(v, fastpathCheckNilTrue, e)
  939     case *map[uint16]int16:
  940         fastpathTV.EncMapUint16Int16V(*v, fastpathCheckNilTrue, e)
  941 
  942     case map[uint16]int32:
  943         fastpathTV.EncMapUint16Int32V(v, fastpathCheckNilTrue, e)
  944     case *map[uint16]int32:
  945         fastpathTV.EncMapUint16Int32V(*v, fastpathCheckNilTrue, e)
  946 
  947     case map[uint16]int64:
  948         fastpathTV.EncMapUint16Int64V(v, fastpathCheckNilTrue, e)
  949     case *map[uint16]int64:
  950         fastpathTV.EncMapUint16Int64V(*v, fastpathCheckNilTrue, e)
  951 
  952     case map[uint16]float32:
  953         fastpathTV.EncMapUint16Float32V(v, fastpathCheckNilTrue, e)
  954     case *map[uint16]float32:
  955         fastpathTV.EncMapUint16Float32V(*v, fastpathCheckNilTrue, e)
  956 
  957     case map[uint16]float64:
  958         fastpathTV.EncMapUint16Float64V(v, fastpathCheckNilTrue, e)
  959     case *map[uint16]float64:
  960         fastpathTV.EncMapUint16Float64V(*v, fastpathCheckNilTrue, e)
  961 
  962     case map[uint16]bool:
  963         fastpathTV.EncMapUint16BoolV(v, fastpathCheckNilTrue, e)
  964     case *map[uint16]bool:
  965         fastpathTV.EncMapUint16BoolV(*v, fastpathCheckNilTrue, e)
  966 
  967     case []uint32:
  968         fastpathTV.EncSliceUint32V(v, fastpathCheckNilTrue, e)
  969     case *[]uint32:
  970         fastpathTV.EncSliceUint32V(*v, fastpathCheckNilTrue, e)
  971 
  972     case map[uint32]interface{}:
  973         fastpathTV.EncMapUint32IntfV(v, fastpathCheckNilTrue, e)
  974     case *map[uint32]interface{}:
  975         fastpathTV.EncMapUint32IntfV(*v, fastpathCheckNilTrue, e)
  976 
  977     case map[uint32]string:
  978         fastpathTV.EncMapUint32StringV(v, fastpathCheckNilTrue, e)
  979     case *map[uint32]string:
  980         fastpathTV.EncMapUint32StringV(*v, fastpathCheckNilTrue, e)
  981 
  982     case map[uint32]uint:
  983         fastpathTV.EncMapUint32UintV(v, fastpathCheckNilTrue, e)
  984     case *map[uint32]uint:
  985         fastpathTV.EncMapUint32UintV(*v, fastpathCheckNilTrue, e)
  986 
  987     case map[uint32]uint8:
  988         fastpathTV.EncMapUint32Uint8V(v, fastpathCheckNilTrue, e)
  989     case *map[uint32]uint8:
  990         fastpathTV.EncMapUint32Uint8V(*v, fastpathCheckNilTrue, e)
  991 
  992     case map[uint32]uint16:
  993         fastpathTV.EncMapUint32Uint16V(v, fastpathCheckNilTrue, e)
  994     case *map[uint32]uint16:
  995         fastpathTV.EncMapUint32Uint16V(*v, fastpathCheckNilTrue, e)
  996 
  997     case map[uint32]uint32:
  998         fastpathTV.EncMapUint32Uint32V(v, fastpathCheckNilTrue, e)
  999     case *map[uint32]uint32:
 1000         fastpathTV.EncMapUint32Uint32V(*v, fastpathCheckNilTrue, e)
 1001 
 1002     case map[uint32]uint64:
 1003         fastpathTV.EncMapUint32Uint64V(v, fastpathCheckNilTrue, e)
 1004     case *map[uint32]uint64:
 1005         fastpathTV.EncMapUint32Uint64V(*v, fastpathCheckNilTrue, e)
 1006 
 1007     case map[uint32]uintptr:
 1008         fastpathTV.EncMapUint32UintptrV(v, fastpathCheckNilTrue, e)
 1009     case *map[uint32]uintptr:
 1010         fastpathTV.EncMapUint32UintptrV(*v, fastpathCheckNilTrue, e)
 1011 
 1012     case map[uint32]int:
 1013         fastpathTV.EncMapUint32IntV(v, fastpathCheckNilTrue, e)
 1014     case *map[uint32]int:
 1015         fastpathTV.EncMapUint32IntV(*v, fastpathCheckNilTrue, e)
 1016 
 1017     case map[uint32]int8:
 1018         fastpathTV.EncMapUint32Int8V(v, fastpathCheckNilTrue, e)
 1019     case *map[uint32]int8:
 1020         fastpathTV.EncMapUint32Int8V(*v, fastpathCheckNilTrue, e)
 1021 
 1022     case map[uint32]int16:
 1023         fastpathTV.EncMapUint32Int16V(v, fastpathCheckNilTrue, e)
 1024     case *map[uint32]int16:
 1025         fastpathTV.EncMapUint32Int16V(*v, fastpathCheckNilTrue, e)
 1026 
 1027     case map[uint32]int32:
 1028         fastpathTV.EncMapUint32Int32V(v, fastpathCheckNilTrue, e)
 1029     case *map[uint32]int32:
 1030         fastpathTV.EncMapUint32Int32V(*v, fastpathCheckNilTrue, e)
 1031 
 1032     case map[uint32]int64:
 1033         fastpathTV.EncMapUint32Int64V(v, fastpathCheckNilTrue, e)
 1034     case *map[uint32]int64:
 1035         fastpathTV.EncMapUint32Int64V(*v, fastpathCheckNilTrue, e)
 1036 
 1037     case map[uint32]float32:
 1038         fastpathTV.EncMapUint32Float32V(v, fastpathCheckNilTrue, e)
 1039     case *map[uint32]float32:
 1040         fastpathTV.EncMapUint32Float32V(*v, fastpathCheckNilTrue, e)
 1041 
 1042     case map[uint32]float64:
 1043         fastpathTV.EncMapUint32Float64V(v, fastpathCheckNilTrue, e)
 1044     case *map[uint32]float64:
 1045         fastpathTV.EncMapUint32Float64V(*v, fastpathCheckNilTrue, e)
 1046 
 1047     case map[uint32]bool:
 1048         fastpathTV.EncMapUint32BoolV(v, fastpathCheckNilTrue, e)
 1049     case *map[uint32]bool:
 1050         fastpathTV.EncMapUint32BoolV(*v, fastpathCheckNilTrue, e)
 1051 
 1052     case []uint64:
 1053         fastpathTV.EncSliceUint64V(v, fastpathCheckNilTrue, e)
 1054     case *[]uint64:
 1055         fastpathTV.EncSliceUint64V(*v, fastpathCheckNilTrue, e)
 1056 
 1057     case map[uint64]interface{}:
 1058         fastpathTV.EncMapUint64IntfV(v, fastpathCheckNilTrue, e)
 1059     case *map[uint64]interface{}:
 1060         fastpathTV.EncMapUint64IntfV(*v, fastpathCheckNilTrue, e)
 1061 
 1062     case map[uint64]string:
 1063         fastpathTV.EncMapUint64StringV(v, fastpathCheckNilTrue, e)
 1064     case *map[uint64]string:
 1065         fastpathTV.EncMapUint64StringV(*v, fastpathCheckNilTrue, e)
 1066 
 1067     case map[uint64]uint:
 1068         fastpathTV.EncMapUint64UintV(v, fastpathCheckNilTrue, e)
 1069     case *map[uint64]uint:
 1070         fastpathTV.EncMapUint64UintV(*v, fastpathCheckNilTrue, e)
 1071 
 1072     case map[uint64]uint8:
 1073         fastpathTV.EncMapUint64Uint8V(v, fastpathCheckNilTrue, e)
 1074     case *map[uint64]uint8:
 1075         fastpathTV.EncMapUint64Uint8V(*v, fastpathCheckNilTrue, e)
 1076 
 1077     case map[uint64]uint16:
 1078         fastpathTV.EncMapUint64Uint16V(v, fastpathCheckNilTrue, e)
 1079     case *map[uint64]uint16:
 1080         fastpathTV.EncMapUint64Uint16V(*v, fastpathCheckNilTrue, e)
 1081 
 1082     case map[uint64]uint32:
 1083         fastpathTV.EncMapUint64Uint32V(v, fastpathCheckNilTrue, e)
 1084     case *map[uint64]uint32:
 1085         fastpathTV.EncMapUint64Uint32V(*v, fastpathCheckNilTrue, e)
 1086 
 1087     case map[uint64]uint64:
 1088         fastpathTV.EncMapUint64Uint64V(v, fastpathCheckNilTrue, e)
 1089     case *map[uint64]uint64:
 1090         fastpathTV.EncMapUint64Uint64V(*v, fastpathCheckNilTrue, e)
 1091 
 1092     case map[uint64]uintptr:
 1093         fastpathTV.EncMapUint64UintptrV(v, fastpathCheckNilTrue, e)
 1094     case *map[uint64]uintptr:
 1095         fastpathTV.EncMapUint64UintptrV(*v, fastpathCheckNilTrue, e)
 1096 
 1097     case map[uint64]int:
 1098         fastpathTV.EncMapUint64IntV(v, fastpathCheckNilTrue, e)
 1099     case *map[uint64]int:
 1100         fastpathTV.EncMapUint64IntV(*v, fastpathCheckNilTrue, e)
 1101 
 1102     case map[uint64]int8:
 1103         fastpathTV.EncMapUint64Int8V(v, fastpathCheckNilTrue, e)
 1104     case *map[uint64]int8:
 1105         fastpathTV.EncMapUint64Int8V(*v, fastpathCheckNilTrue, e)
 1106 
 1107     case map[uint64]int16:
 1108         fastpathTV.EncMapUint64Int16V(v, fastpathCheckNilTrue, e)
 1109     case *map[uint64]int16:
 1110         fastpathTV.EncMapUint64Int16V(*v, fastpathCheckNilTrue, e)
 1111 
 1112     case map[uint64]int32:
 1113         fastpathTV.EncMapUint64Int32V(v, fastpathCheckNilTrue, e)
 1114     case *map[uint64]int32:
 1115         fastpathTV.EncMapUint64Int32V(*v, fastpathCheckNilTrue, e)
 1116 
 1117     case map[uint64]int64:
 1118         fastpathTV.EncMapUint64Int64V(v, fastpathCheckNilTrue, e)
 1119     case *map[uint64]int64:
 1120         fastpathTV.EncMapUint64Int64V(*v, fastpathCheckNilTrue, e)
 1121 
 1122     case map[uint64]float32:
 1123         fastpathTV.EncMapUint64Float32V(v, fastpathCheckNilTrue, e)
 1124     case *map[uint64]float32:
 1125         fastpathTV.EncMapUint64Float32V(*v, fastpathCheckNilTrue, e)
 1126 
 1127     case map[uint64]float64:
 1128         fastpathTV.EncMapUint64Float64V(v, fastpathCheckNilTrue, e)
 1129     case *map[uint64]float64:
 1130         fastpathTV.EncMapUint64Float64V(*v, fastpathCheckNilTrue, e)
 1131 
 1132     case map[uint64]bool:
 1133         fastpathTV.EncMapUint64BoolV(v, fastpathCheckNilTrue, e)
 1134     case *map[uint64]bool:
 1135         fastpathTV.EncMapUint64BoolV(*v, fastpathCheckNilTrue, e)
 1136 
 1137     case []uintptr:
 1138         fastpathTV.EncSliceUintptrV(v, fastpathCheckNilTrue, e)
 1139     case *[]uintptr:
 1140         fastpathTV.EncSliceUintptrV(*v, fastpathCheckNilTrue, e)
 1141 
 1142     case map[uintptr]interface{}:
 1143         fastpathTV.EncMapUintptrIntfV(v, fastpathCheckNilTrue, e)
 1144     case *map[uintptr]interface{}:
 1145         fastpathTV.EncMapUintptrIntfV(*v, fastpathCheckNilTrue, e)
 1146 
 1147     case map[uintptr]string:
 1148         fastpathTV.EncMapUintptrStringV(v, fastpathCheckNilTrue, e)
 1149     case *map[uintptr]string:
 1150         fastpathTV.EncMapUintptrStringV(*v, fastpathCheckNilTrue, e)
 1151 
 1152     case map[uintptr]uint:
 1153         fastpathTV.EncMapUintptrUintV(v, fastpathCheckNilTrue, e)
 1154     case *map[uintptr]uint:
 1155         fastpathTV.EncMapUintptrUintV(*v, fastpathCheckNilTrue, e)
 1156 
 1157     case map[uintptr]uint8:
 1158         fastpathTV.EncMapUintptrUint8V(v, fastpathCheckNilTrue, e)
 1159     case *map[uintptr]uint8:
 1160         fastpathTV.EncMapUintptrUint8V(*v, fastpathCheckNilTrue, e)
 1161 
 1162     case map[uintptr]uint16:
 1163         fastpathTV.EncMapUintptrUint16V(v, fastpathCheckNilTrue, e)
 1164     case *map[uintptr]uint16:
 1165         fastpathTV.EncMapUintptrUint16V(*v, fastpathCheckNilTrue, e)
 1166 
 1167     case map[uintptr]uint32:
 1168         fastpathTV.EncMapUintptrUint32V(v, fastpathCheckNilTrue, e)
 1169     case *map[uintptr]uint32:
 1170         fastpathTV.EncMapUintptrUint32V(*v, fastpathCheckNilTrue, e)
 1171 
 1172     case map[uintptr]uint64:
 1173         fastpathTV.EncMapUintptrUint64V(v, fastpathCheckNilTrue, e)
 1174     case *map[uintptr]uint64:
 1175         fastpathTV.EncMapUintptrUint64V(*v, fastpathCheckNilTrue, e)
 1176 
 1177     case map[uintptr]uintptr:
 1178         fastpathTV.EncMapUintptrUintptrV(v, fastpathCheckNilTrue, e)
 1179     case *map[uintptr]uintptr:
 1180         fastpathTV.EncMapUintptrUintptrV(*v, fastpathCheckNilTrue, e)
 1181 
 1182     case map[uintptr]int:
 1183         fastpathTV.EncMapUintptrIntV(v, fastpathCheckNilTrue, e)
 1184     case *map[uintptr]int:
 1185         fastpathTV.EncMapUintptrIntV(*v, fastpathCheckNilTrue, e)
 1186 
 1187     case map[uintptr]int8:
 1188         fastpathTV.EncMapUintptrInt8V(v, fastpathCheckNilTrue, e)
 1189     case *map[uintptr]int8:
 1190         fastpathTV.EncMapUintptrInt8V(*v, fastpathCheckNilTrue, e)
 1191 
 1192     case map[uintptr]int16:
 1193         fastpathTV.EncMapUintptrInt16V(v, fastpathCheckNilTrue, e)
 1194     case *map[uintptr]int16:
 1195         fastpathTV.EncMapUintptrInt16V(*v, fastpathCheckNilTrue, e)
 1196 
 1197     case map[uintptr]int32:
 1198         fastpathTV.EncMapUintptrInt32V(v, fastpathCheckNilTrue, e)
 1199     case *map[uintptr]int32:
 1200         fastpathTV.EncMapUintptrInt32V(*v, fastpathCheckNilTrue, e)
 1201 
 1202     case map[uintptr]int64:
 1203         fastpathTV.EncMapUintptrInt64V(v, fastpathCheckNilTrue, e)
 1204     case *map[uintptr]int64:
 1205         fastpathTV.EncMapUintptrInt64V(*v, fastpathCheckNilTrue, e)
 1206 
 1207     case map[uintptr]float32:
 1208         fastpathTV.EncMapUintptrFloat32V(v, fastpathCheckNilTrue, e)
 1209     case *map[uintptr]float32:
 1210         fastpathTV.EncMapUintptrFloat32V(*v, fastpathCheckNilTrue, e)
 1211 
 1212     case map[uintptr]float64:
 1213         fastpathTV.EncMapUintptrFloat64V(v, fastpathCheckNilTrue, e)
 1214     case *map[uintptr]float64:
 1215         fastpathTV.EncMapUintptrFloat64V(*v, fastpathCheckNilTrue, e)
 1216 
 1217     case map[uintptr]bool:
 1218         fastpathTV.EncMapUintptrBoolV(v, fastpathCheckNilTrue, e)
 1219     case *map[uintptr]bool:
 1220         fastpathTV.EncMapUintptrBoolV(*v, fastpathCheckNilTrue, e)
 1221 
 1222     case []int:
 1223         fastpathTV.EncSliceIntV(v, fastpathCheckNilTrue, e)
 1224     case *[]int:
 1225         fastpathTV.EncSliceIntV(*v, fastpathCheckNilTrue, e)
 1226 
 1227     case map[int]interface{}:
 1228         fastpathTV.EncMapIntIntfV(v, fastpathCheckNilTrue, e)
 1229     case *map[int]interface{}:
 1230         fastpathTV.EncMapIntIntfV(*v, fastpathCheckNilTrue, e)
 1231 
 1232     case map[int]string:
 1233         fastpathTV.EncMapIntStringV(v, fastpathCheckNilTrue, e)
 1234     case *map[int]string:
 1235         fastpathTV.EncMapIntStringV(*v, fastpathCheckNilTrue, e)
 1236 
 1237     case map[int]uint:
 1238         fastpathTV.EncMapIntUintV(v, fastpathCheckNilTrue, e)
 1239     case *map[int]uint:
 1240         fastpathTV.EncMapIntUintV(*v, fastpathCheckNilTrue, e)
 1241 
 1242     case map[int]uint8:
 1243         fastpathTV.EncMapIntUint8V(v, fastpathCheckNilTrue, e)
 1244     case *map[int]uint8:
 1245         fastpathTV.EncMapIntUint8V(*v, fastpathCheckNilTrue, e)
 1246 
 1247     case map[int]uint16:
 1248         fastpathTV.EncMapIntUint16V(v, fastpathCheckNilTrue, e)
 1249     case *map[int]uint16:
 1250         fastpathTV.EncMapIntUint16V(*v, fastpathCheckNilTrue, e)
 1251 
 1252     case map[int]uint32:
 1253         fastpathTV.EncMapIntUint32V(v, fastpathCheckNilTrue, e)
 1254     case *map[int]uint32:
 1255         fastpathTV.EncMapIntUint32V(*v, fastpathCheckNilTrue, e)
 1256 
 1257     case map[int]uint64:
 1258         fastpathTV.EncMapIntUint64V(v, fastpathCheckNilTrue, e)
 1259     case *map[int]uint64:
 1260         fastpathTV.EncMapIntUint64V(*v, fastpathCheckNilTrue, e)
 1261 
 1262     case map[int]uintptr:
 1263         fastpathTV.EncMapIntUintptrV(v, fastpathCheckNilTrue, e)
 1264     case *map[int]uintptr:
 1265         fastpathTV.EncMapIntUintptrV(*v, fastpathCheckNilTrue, e)
 1266 
 1267     case map[int]int:
 1268         fastpathTV.EncMapIntIntV(v, fastpathCheckNilTrue, e)
 1269     case *map[int]int:
 1270         fastpathTV.EncMapIntIntV(*v, fastpathCheckNilTrue, e)
 1271 
 1272     case map[int]int8:
 1273         fastpathTV.EncMapIntInt8V(v, fastpathCheckNilTrue, e)
 1274     case *map[int]int8:
 1275         fastpathTV.EncMapIntInt8V(*v, fastpathCheckNilTrue, e)
 1276 
 1277     case map[int]int16:
 1278         fastpathTV.EncMapIntInt16V(v, fastpathCheckNilTrue, e)
 1279     case *map[int]int16:
 1280         fastpathTV.EncMapIntInt16V(*v, fastpathCheckNilTrue, e)
 1281 
 1282     case map[int]int32:
 1283         fastpathTV.EncMapIntInt32V(v, fastpathCheckNilTrue, e)
 1284     case *map[int]int32:
 1285         fastpathTV.EncMapIntInt32V(*v, fastpathCheckNilTrue, e)
 1286 
 1287     case map[int]int64:
 1288         fastpathTV.EncMapIntInt64V(v, fastpathCheckNilTrue, e)
 1289     case *map[int]int64:
 1290         fastpathTV.EncMapIntInt64V(*v, fastpathCheckNilTrue, e)
 1291 
 1292     case map[int]float32:
 1293         fastpathTV.EncMapIntFloat32V(v, fastpathCheckNilTrue, e)
 1294     case *map[int]float32:
 1295         fastpathTV.EncMapIntFloat32V(*v, fastpathCheckNilTrue, e)
 1296 
 1297     case map[int]float64:
 1298         fastpathTV.EncMapIntFloat64V(v, fastpathCheckNilTrue, e)
 1299     case *map[int]float64:
 1300         fastpathTV.EncMapIntFloat64V(*v, fastpathCheckNilTrue, e)
 1301 
 1302     case map[int]bool:
 1303         fastpathTV.EncMapIntBoolV(v, fastpathCheckNilTrue, e)
 1304     case *map[int]bool:
 1305         fastpathTV.EncMapIntBoolV(*v, fastpathCheckNilTrue, e)
 1306 
 1307     case []int8:
 1308         fastpathTV.EncSliceInt8V(v, fastpathCheckNilTrue, e)
 1309     case *[]int8:
 1310         fastpathTV.EncSliceInt8V(*v, fastpathCheckNilTrue, e)
 1311 
 1312     case map[int8]interface{}:
 1313         fastpathTV.EncMapInt8IntfV(v, fastpathCheckNilTrue, e)
 1314     case *map[int8]interface{}:
 1315         fastpathTV.EncMapInt8IntfV(*v, fastpathCheckNilTrue, e)
 1316 
 1317     case map[int8]string:
 1318         fastpathTV.EncMapInt8StringV(v, fastpathCheckNilTrue, e)
 1319     case *map[int8]string:
 1320         fastpathTV.EncMapInt8StringV(*v, fastpathCheckNilTrue, e)
 1321 
 1322     case map[int8]uint:
 1323         fastpathTV.EncMapInt8UintV(v, fastpathCheckNilTrue, e)
 1324     case *map[int8]uint:
 1325         fastpathTV.EncMapInt8UintV(*v, fastpathCheckNilTrue, e)
 1326 
 1327     case map[int8]uint8:
 1328         fastpathTV.EncMapInt8Uint8V(v, fastpathCheckNilTrue, e)
 1329     case *map[int8]uint8:
 1330         fastpathTV.EncMapInt8Uint8V(*v, fastpathCheckNilTrue, e)
 1331 
 1332     case map[int8]uint16:
 1333         fastpathTV.EncMapInt8Uint16V(v, fastpathCheckNilTrue, e)
 1334     case *map[int8]uint16:
 1335         fastpathTV.EncMapInt8Uint16V(*v, fastpathCheckNilTrue, e)
 1336 
 1337     case map[int8]uint32:
 1338         fastpathTV.EncMapInt8Uint32V(v, fastpathCheckNilTrue, e)
 1339     case *map[int8]uint32:
 1340         fastpathTV.EncMapInt8Uint32V(*v, fastpathCheckNilTrue, e)
 1341 
 1342     case map[int8]uint64:
 1343         fastpathTV.EncMapInt8Uint64V(v, fastpathCheckNilTrue, e)
 1344     case *map[int8]uint64:
 1345         fastpathTV.EncMapInt8Uint64V(*v, fastpathCheckNilTrue, e)
 1346 
 1347     case map[int8]uintptr:
 1348         fastpathTV.EncMapInt8UintptrV(v, fastpathCheckNilTrue, e)
 1349     case *map[int8]uintptr:
 1350         fastpathTV.EncMapInt8UintptrV(*v, fastpathCheckNilTrue, e)
 1351 
 1352     case map[int8]int:
 1353         fastpathTV.EncMapInt8IntV(v, fastpathCheckNilTrue, e)
 1354     case *map[int8]int:
 1355         fastpathTV.EncMapInt8IntV(*v, fastpathCheckNilTrue, e)
 1356 
 1357     case map[int8]int8:
 1358         fastpathTV.EncMapInt8Int8V(v, fastpathCheckNilTrue, e)
 1359     case *map[int8]int8:
 1360         fastpathTV.EncMapInt8Int8V(*v, fastpathCheckNilTrue, e)
 1361 
 1362     case map[int8]int16:
 1363         fastpathTV.EncMapInt8Int16V(v, fastpathCheckNilTrue, e)
 1364     case *map[int8]int16:
 1365         fastpathTV.EncMapInt8Int16V(*v, fastpathCheckNilTrue, e)
 1366 
 1367     case map[int8]int32:
 1368         fastpathTV.EncMapInt8Int32V(v, fastpathCheckNilTrue, e)
 1369     case *map[int8]int32:
 1370         fastpathTV.EncMapInt8Int32V(*v, fastpathCheckNilTrue, e)
 1371 
 1372     case map[int8]int64:
 1373         fastpathTV.EncMapInt8Int64V(v, fastpathCheckNilTrue, e)
 1374     case *map[int8]int64:
 1375         fastpathTV.EncMapInt8Int64V(*v, fastpathCheckNilTrue, e)
 1376 
 1377     case map[int8]float32:
 1378         fastpathTV.EncMapInt8Float32V(v, fastpathCheckNilTrue, e)
 1379     case *map[int8]float32:
 1380         fastpathTV.EncMapInt8Float32V(*v, fastpathCheckNilTrue, e)
 1381 
 1382     case map[int8]float64:
 1383         fastpathTV.EncMapInt8Float64V(v, fastpathCheckNilTrue, e)
 1384     case *map[int8]float64:
 1385         fastpathTV.EncMapInt8Float64V(*v, fastpathCheckNilTrue, e)
 1386 
 1387     case map[int8]bool:
 1388         fastpathTV.EncMapInt8BoolV(v, fastpathCheckNilTrue, e)
 1389     case *map[int8]bool:
 1390         fastpathTV.EncMapInt8BoolV(*v, fastpathCheckNilTrue, e)
 1391 
 1392     case []int16:
 1393         fastpathTV.EncSliceInt16V(v, fastpathCheckNilTrue, e)
 1394     case *[]int16:
 1395         fastpathTV.EncSliceInt16V(*v, fastpathCheckNilTrue, e)
 1396 
 1397     case map[int16]interface{}:
 1398         fastpathTV.EncMapInt16IntfV(v, fastpathCheckNilTrue, e)
 1399     case *map[int16]interface{}:
 1400         fastpathTV.EncMapInt16IntfV(*v, fastpathCheckNilTrue, e)
 1401 
 1402     case map[int16]string:
 1403         fastpathTV.EncMapInt16StringV(v, fastpathCheckNilTrue, e)
 1404     case *map[int16]string:
 1405         fastpathTV.EncMapInt16StringV(*v, fastpathCheckNilTrue, e)
 1406 
 1407     case map[int16]uint:
 1408         fastpathTV.EncMapInt16UintV(v, fastpathCheckNilTrue, e)
 1409     case *map[int16]uint:
 1410         fastpathTV.EncMapInt16UintV(*v, fastpathCheckNilTrue, e)
 1411 
 1412     case map[int16]uint8:
 1413         fastpathTV.EncMapInt16Uint8V(v, fastpathCheckNilTrue, e)
 1414     case *map[int16]uint8:
 1415         fastpathTV.EncMapInt16Uint8V(*v, fastpathCheckNilTrue, e)
 1416 
 1417     case map[int16]uint16:
 1418         fastpathTV.EncMapInt16Uint16V(v, fastpathCheckNilTrue, e)
 1419     case *map[int16]uint16:
 1420         fastpathTV.EncMapInt16Uint16V(*v, fastpathCheckNilTrue, e)
 1421 
 1422     case map[int16]uint32:
 1423         fastpathTV.EncMapInt16Uint32V(v, fastpathCheckNilTrue, e)
 1424     case *map[int16]uint32:
 1425         fastpathTV.EncMapInt16Uint32V(*v, fastpathCheckNilTrue, e)
 1426 
 1427     case map[int16]uint64:
 1428         fastpathTV.EncMapInt16Uint64V(v, fastpathCheckNilTrue, e)
 1429     case *map[int16]uint64:
 1430         fastpathTV.EncMapInt16Uint64V(*v, fastpathCheckNilTrue, e)
 1431 
 1432     case map[int16]uintptr:
 1433         fastpathTV.EncMapInt16UintptrV(v, fastpathCheckNilTrue, e)
 1434     case *map[int16]uintptr:
 1435         fastpathTV.EncMapInt16UintptrV(*v, fastpathCheckNilTrue, e)
 1436 
 1437     case map[int16]int:
 1438         fastpathTV.EncMapInt16IntV(v, fastpathCheckNilTrue, e)
 1439     case *map[int16]int:
 1440         fastpathTV.EncMapInt16IntV(*v, fastpathCheckNilTrue, e)
 1441 
 1442     case map[int16]int8:
 1443         fastpathTV.EncMapInt16Int8V(v, fastpathCheckNilTrue, e)
 1444     case *map[int16]int8:
 1445         fastpathTV.EncMapInt16Int8V(*v, fastpathCheckNilTrue, e)
 1446 
 1447     case map[int16]int16:
 1448         fastpathTV.EncMapInt16Int16V(v, fastpathCheckNilTrue, e)
 1449     case *map[int16]int16:
 1450         fastpathTV.EncMapInt16Int16V(*v, fastpathCheckNilTrue, e)
 1451 
 1452     case map[int16]int32:
 1453         fastpathTV.EncMapInt16Int32V(v, fastpathCheckNilTrue, e)
 1454     case *map[int16]int32:
 1455         fastpathTV.EncMapInt16Int32V(*v, fastpathCheckNilTrue, e)
 1456 
 1457     case map[int16]int64:
 1458         fastpathTV.EncMapInt16Int64V(v, fastpathCheckNilTrue, e)
 1459     case *map[int16]int64:
 1460         fastpathTV.EncMapInt16Int64V(*v, fastpathCheckNilTrue, e)
 1461 
 1462     case map[int16]float32:
 1463         fastpathTV.EncMapInt16Float32V(v, fastpathCheckNilTrue, e)
 1464     case *map[int16]float32:
 1465         fastpathTV.EncMapInt16Float32V(*v, fastpathCheckNilTrue, e)
 1466 
 1467     case map[int16]float64:
 1468         fastpathTV.EncMapInt16Float64V(v, fastpathCheckNilTrue, e)
 1469     case *map[int16]float64:
 1470         fastpathTV.EncMapInt16Float64V(*v, fastpathCheckNilTrue, e)
 1471 
 1472     case map[int16]bool:
 1473         fastpathTV.EncMapInt16BoolV(v, fastpathCheckNilTrue, e)
 1474     case *map[int16]bool:
 1475         fastpathTV.EncMapInt16BoolV(*v, fastpathCheckNilTrue, e)
 1476 
 1477     case []int32:
 1478         fastpathTV.EncSliceInt32V(v, fastpathCheckNilTrue, e)
 1479     case *[]int32:
 1480         fastpathTV.EncSliceInt32V(*v, fastpathCheckNilTrue, e)
 1481 
 1482     case map[int32]interface{}:
 1483         fastpathTV.EncMapInt32IntfV(v, fastpathCheckNilTrue, e)
 1484     case *map[int32]interface{}:
 1485         fastpathTV.EncMapInt32IntfV(*v, fastpathCheckNilTrue, e)
 1486 
 1487     case map[int32]string:
 1488         fastpathTV.EncMapInt32StringV(v, fastpathCheckNilTrue, e)
 1489     case *map[int32]string:
 1490         fastpathTV.EncMapInt32StringV(*v, fastpathCheckNilTrue, e)
 1491 
 1492     case map[int32]uint:
 1493         fastpathTV.EncMapInt32UintV(v, fastpathCheckNilTrue, e)
 1494     case *map[int32]uint:
 1495         fastpathTV.EncMapInt32UintV(*v, fastpathCheckNilTrue, e)
 1496 
 1497     case map[int32]uint8:
 1498         fastpathTV.EncMapInt32Uint8V(v, fastpathCheckNilTrue, e)
 1499     case *map[int32]uint8:
 1500         fastpathTV.EncMapInt32Uint8V(*v, fastpathCheckNilTrue, e)
 1501 
 1502     case map[int32]uint16:
 1503         fastpathTV.EncMapInt32Uint16V(v, fastpathCheckNilTrue, e)
 1504     case *map[int32]uint16:
 1505         fastpathTV.EncMapInt32Uint16V(*v, fastpathCheckNilTrue, e)
 1506 
 1507     case map[int32]uint32:
 1508         fastpathTV.EncMapInt32Uint32V(v, fastpathCheckNilTrue, e)
 1509     case *map[int32]uint32:
 1510         fastpathTV.EncMapInt32Uint32V(*v, fastpathCheckNilTrue, e)
 1511 
 1512     case map[int32]uint64:
 1513         fastpathTV.EncMapInt32Uint64V(v, fastpathCheckNilTrue, e)
 1514     case *map[int32]uint64:
 1515         fastpathTV.EncMapInt32Uint64V(*v, fastpathCheckNilTrue, e)
 1516 
 1517     case map[int32]uintptr:
 1518         fastpathTV.EncMapInt32UintptrV(v, fastpathCheckNilTrue, e)
 1519     case *map[int32]uintptr:
 1520         fastpathTV.EncMapInt32UintptrV(*v, fastpathCheckNilTrue, e)
 1521 
 1522     case map[int32]int:
 1523         fastpathTV.EncMapInt32IntV(v, fastpathCheckNilTrue, e)
 1524     case *map[int32]int:
 1525         fastpathTV.EncMapInt32IntV(*v, fastpathCheckNilTrue, e)
 1526 
 1527     case map[int32]int8:
 1528         fastpathTV.EncMapInt32Int8V(v, fastpathCheckNilTrue, e)
 1529     case *map[int32]int8:
 1530         fastpathTV.EncMapInt32Int8V(*v, fastpathCheckNilTrue, e)
 1531 
 1532     case map[int32]int16:
 1533         fastpathTV.EncMapInt32Int16V(v, fastpathCheckNilTrue, e)
 1534     case *map[int32]int16:
 1535         fastpathTV.EncMapInt32Int16V(*v, fastpathCheckNilTrue, e)
 1536 
 1537     case map[int32]int32:
 1538         fastpathTV.EncMapInt32Int32V(v, fastpathCheckNilTrue, e)
 1539     case *map[int32]int32:
 1540         fastpathTV.EncMapInt32Int32V(*v, fastpathCheckNilTrue, e)
 1541 
 1542     case map[int32]int64:
 1543         fastpathTV.EncMapInt32Int64V(v, fastpathCheckNilTrue, e)
 1544     case *map[int32]int64:
 1545         fastpathTV.EncMapInt32Int64V(*v, fastpathCheckNilTrue, e)
 1546 
 1547     case map[int32]float32:
 1548         fastpathTV.EncMapInt32Float32V(v, fastpathCheckNilTrue, e)
 1549     case *map[int32]float32:
 1550         fastpathTV.EncMapInt32Float32V(*v, fastpathCheckNilTrue, e)
 1551 
 1552     case map[int32]float64:
 1553         fastpathTV.EncMapInt32Float64V(v, fastpathCheckNilTrue, e)
 1554     case *map[int32]float64:
 1555         fastpathTV.EncMapInt32Float64V(*v, fastpathCheckNilTrue, e)
 1556 
 1557     case map[int32]bool:
 1558         fastpathTV.EncMapInt32BoolV(v, fastpathCheckNilTrue, e)
 1559     case *map[int32]bool:
 1560         fastpathTV.EncMapInt32BoolV(*v, fastpathCheckNilTrue, e)
 1561 
 1562     case []int64:
 1563         fastpathTV.EncSliceInt64V(v, fastpathCheckNilTrue, e)
 1564     case *[]int64:
 1565         fastpathTV.EncSliceInt64V(*v, fastpathCheckNilTrue, e)
 1566 
 1567     case map[int64]interface{}:
 1568         fastpathTV.EncMapInt64IntfV(v, fastpathCheckNilTrue, e)
 1569     case *map[int64]interface{}:
 1570         fastpathTV.EncMapInt64IntfV(*v, fastpathCheckNilTrue, e)
 1571 
 1572     case map[int64]string:
 1573         fastpathTV.EncMapInt64StringV(v, fastpathCheckNilTrue, e)
 1574     case *map[int64]string:
 1575         fastpathTV.EncMapInt64StringV(*v, fastpathCheckNilTrue, e)
 1576 
 1577     case map[int64]uint:
 1578         fastpathTV.EncMapInt64UintV(v, fastpathCheckNilTrue, e)
 1579     case *map[int64]uint:
 1580         fastpathTV.EncMapInt64UintV(*v, fastpathCheckNilTrue, e)
 1581 
 1582     case map[int64]uint8:
 1583         fastpathTV.EncMapInt64Uint8V(v, fastpathCheckNilTrue, e)
 1584     case *map[int64]uint8:
 1585         fastpathTV.EncMapInt64Uint8V(*v, fastpathCheckNilTrue, e)
 1586 
 1587     case map[int64]uint16:
 1588         fastpathTV.EncMapInt64Uint16V(v, fastpathCheckNilTrue, e)
 1589     case *map[int64]uint16:
 1590         fastpathTV.EncMapInt64Uint16V(*v, fastpathCheckNilTrue, e)
 1591 
 1592     case map[int64]uint32:
 1593         fastpathTV.EncMapInt64Uint32V(v, fastpathCheckNilTrue, e)
 1594     case *map[int64]uint32:
 1595         fastpathTV.EncMapInt64Uint32V(*v, fastpathCheckNilTrue, e)
 1596 
 1597     case map[int64]uint64:
 1598         fastpathTV.EncMapInt64Uint64V(v, fastpathCheckNilTrue, e)
 1599     case *map[int64]uint64:
 1600         fastpathTV.EncMapInt64Uint64V(*v, fastpathCheckNilTrue, e)
 1601 
 1602     case map[int64]uintptr:
 1603         fastpathTV.EncMapInt64UintptrV(v, fastpathCheckNilTrue, e)
 1604     case *map[int64]uintptr:
 1605         fastpathTV.EncMapInt64UintptrV(*v, fastpathCheckNilTrue, e)
 1606 
 1607     case map[int64]int:
 1608         fastpathTV.EncMapInt64IntV(v, fastpathCheckNilTrue, e)
 1609     case *map[int64]int:
 1610         fastpathTV.EncMapInt64IntV(*v, fastpathCheckNilTrue, e)
 1611 
 1612     case map[int64]int8:
 1613         fastpathTV.EncMapInt64Int8V(v, fastpathCheckNilTrue, e)
 1614     case *map[int64]int8:
 1615         fastpathTV.EncMapInt64Int8V(*v, fastpathCheckNilTrue, e)
 1616 
 1617     case map[int64]int16:
 1618         fastpathTV.EncMapInt64Int16V(v, fastpathCheckNilTrue, e)
 1619     case *map[int64]int16:
 1620         fastpathTV.EncMapInt64Int16V(*v, fastpathCheckNilTrue, e)
 1621 
 1622     case map[int64]int32:
 1623         fastpathTV.EncMapInt64Int32V(v, fastpathCheckNilTrue, e)
 1624     case *map[int64]int32:
 1625         fastpathTV.EncMapInt64Int32V(*v, fastpathCheckNilTrue, e)
 1626 
 1627     case map[int64]int64:
 1628         fastpathTV.EncMapInt64Int64V(v, fastpathCheckNilTrue, e)
 1629     case *map[int64]int64:
 1630         fastpathTV.EncMapInt64Int64V(*v, fastpathCheckNilTrue, e)
 1631 
 1632     case map[int64]float32:
 1633         fastpathTV.EncMapInt64Float32V(v, fastpathCheckNilTrue, e)
 1634     case *map[int64]float32:
 1635         fastpathTV.EncMapInt64Float32V(*v, fastpathCheckNilTrue, e)
 1636 
 1637     case map[int64]float64:
 1638         fastpathTV.EncMapInt64Float64V(v, fastpathCheckNilTrue, e)
 1639     case *map[int64]float64:
 1640         fastpathTV.EncMapInt64Float64V(*v, fastpathCheckNilTrue, e)
 1641 
 1642     case map[int64]bool:
 1643         fastpathTV.EncMapInt64BoolV(v, fastpathCheckNilTrue, e)
 1644     case *map[int64]bool:
 1645         fastpathTV.EncMapInt64BoolV(*v, fastpathCheckNilTrue, e)
 1646 
 1647     case []bool:
 1648         fastpathTV.EncSliceBoolV(v, fastpathCheckNilTrue, e)
 1649     case *[]bool:
 1650         fastpathTV.EncSliceBoolV(*v, fastpathCheckNilTrue, e)
 1651 
 1652     case map[bool]interface{}:
 1653         fastpathTV.EncMapBoolIntfV(v, fastpathCheckNilTrue, e)
 1654     case *map[bool]interface{}:
 1655         fastpathTV.EncMapBoolIntfV(*v, fastpathCheckNilTrue, e)
 1656 
 1657     case map[bool]string:
 1658         fastpathTV.EncMapBoolStringV(v, fastpathCheckNilTrue, e)
 1659     case *map[bool]string:
 1660         fastpathTV.EncMapBoolStringV(*v, fastpathCheckNilTrue, e)
 1661 
 1662     case map[bool]uint:
 1663         fastpathTV.EncMapBoolUintV(v, fastpathCheckNilTrue, e)
 1664     case *map[bool]uint:
 1665         fastpathTV.EncMapBoolUintV(*v, fastpathCheckNilTrue, e)
 1666 
 1667     case map[bool]uint8:
 1668         fastpathTV.EncMapBoolUint8V(v, fastpathCheckNilTrue, e)
 1669     case *map[bool]uint8:
 1670         fastpathTV.EncMapBoolUint8V(*v, fastpathCheckNilTrue, e)
 1671 
 1672     case map[bool]uint16:
 1673         fastpathTV.EncMapBoolUint16V(v, fastpathCheckNilTrue, e)
 1674     case *map[bool]uint16:
 1675         fastpathTV.EncMapBoolUint16V(*v, fastpathCheckNilTrue, e)
 1676 
 1677     case map[bool]uint32:
 1678         fastpathTV.EncMapBoolUint32V(v, fastpathCheckNilTrue, e)
 1679     case *map[bool]uint32:
 1680         fastpathTV.EncMapBoolUint32V(*v, fastpathCheckNilTrue, e)
 1681 
 1682     case map[bool]uint64:
 1683         fastpathTV.EncMapBoolUint64V(v, fastpathCheckNilTrue, e)
 1684     case *map[bool]uint64:
 1685         fastpathTV.EncMapBoolUint64V(*v, fastpathCheckNilTrue, e)
 1686 
 1687     case map[bool]uintptr:
 1688         fastpathTV.EncMapBoolUintptrV(v, fastpathCheckNilTrue, e)
 1689     case *map[bool]uintptr:
 1690         fastpathTV.EncMapBoolUintptrV(*v, fastpathCheckNilTrue, e)
 1691 
 1692     case map[bool]int:
 1693         fastpathTV.EncMapBoolIntV(v, fastpathCheckNilTrue, e)
 1694     case *map[bool]int:
 1695         fastpathTV.EncMapBoolIntV(*v, fastpathCheckNilTrue, e)
 1696 
 1697     case map[bool]int8:
 1698         fastpathTV.EncMapBoolInt8V(v, fastpathCheckNilTrue, e)
 1699     case *map[bool]int8:
 1700         fastpathTV.EncMapBoolInt8V(*v, fastpathCheckNilTrue, e)
 1701 
 1702     case map[bool]int16:
 1703         fastpathTV.EncMapBoolInt16V(v, fastpathCheckNilTrue, e)
 1704     case *map[bool]int16:
 1705         fastpathTV.EncMapBoolInt16V(*v, fastpathCheckNilTrue, e)
 1706 
 1707     case map[bool]int32:
 1708         fastpathTV.EncMapBoolInt32V(v, fastpathCheckNilTrue, e)
 1709     case *map[bool]int32:
 1710         fastpathTV.EncMapBoolInt32V(*v, fastpathCheckNilTrue, e)
 1711 
 1712     case map[bool]int64:
 1713         fastpathTV.EncMapBoolInt64V(v, fastpathCheckNilTrue, e)
 1714     case *map[bool]int64:
 1715         fastpathTV.EncMapBoolInt64V(*v, fastpathCheckNilTrue, e)
 1716 
 1717     case map[bool]float32:
 1718         fastpathTV.EncMapBoolFloat32V(v, fastpathCheckNilTrue, e)
 1719     case *map[bool]float32:
 1720         fastpathTV.EncMapBoolFloat32V(*v, fastpathCheckNilTrue, e)
 1721 
 1722     case map[bool]float64:
 1723         fastpathTV.EncMapBoolFloat64V(v, fastpathCheckNilTrue, e)
 1724     case *map[bool]float64:
 1725         fastpathTV.EncMapBoolFloat64V(*v, fastpathCheckNilTrue, e)
 1726 
 1727     case map[bool]bool:
 1728         fastpathTV.EncMapBoolBoolV(v, fastpathCheckNilTrue, e)
 1729     case *map[bool]bool:
 1730         fastpathTV.EncMapBoolBoolV(*v, fastpathCheckNilTrue, e)
 1731 
 1732     default:
 1733         _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
 1734         return false
 1735     }
 1736     return true
 1737 }
 1738 
 1739 func fastpathEncodeTypeSwitchSlice(iv interface{}, e *Encoder) bool {
 1740     switch v := iv.(type) {
 1741 
 1742     case []interface{}:
 1743         fastpathTV.EncSliceIntfV(v, fastpathCheckNilTrue, e)
 1744     case *[]interface{}:
 1745         fastpathTV.EncSliceIntfV(*v, fastpathCheckNilTrue, e)
 1746 
 1747     case []string:
 1748         fastpathTV.EncSliceStringV(v, fastpathCheckNilTrue, e)
 1749     case *[]string:
 1750         fastpathTV.EncSliceStringV(*v, fastpathCheckNilTrue, e)
 1751 
 1752     case []float32:
 1753         fastpathTV.EncSliceFloat32V(v, fastpathCheckNilTrue, e)
 1754     case *[]float32:
 1755         fastpathTV.EncSliceFloat32V(*v, fastpathCheckNilTrue, e)
 1756 
 1757     case []float64:
 1758         fastpathTV.EncSliceFloat64V(v, fastpathCheckNilTrue, e)
 1759     case *[]float64:
 1760         fastpathTV.EncSliceFloat64V(*v, fastpathCheckNilTrue, e)
 1761 
 1762     case []uint:
 1763         fastpathTV.EncSliceUintV(v, fastpathCheckNilTrue, e)
 1764     case *[]uint:
 1765         fastpathTV.EncSliceUintV(*v, fastpathCheckNilTrue, e)
 1766 
 1767     case []uint16:
 1768         fastpathTV.EncSliceUint16V(v, fastpathCheckNilTrue, e)
 1769     case *[]uint16:
 1770         fastpathTV.EncSliceUint16V(*v, fastpathCheckNilTrue, e)
 1771 
 1772     case []uint32:
 1773         fastpathTV.EncSliceUint32V(v, fastpathCheckNilTrue, e)
 1774     case *[]uint32:
 1775         fastpathTV.EncSliceUint32V(*v, fastpathCheckNilTrue, e)
 1776 
 1777     case []uint64:
 1778         fastpathTV.EncSliceUint64V(v, fastpathCheckNilTrue, e)
 1779     case *[]uint64:
 1780         fastpathTV.EncSliceUint64V(*v, fastpathCheckNilTrue, e)
 1781 
 1782     case []uintptr:
 1783         fastpathTV.EncSliceUintptrV(v, fastpathCheckNilTrue, e)
 1784     case *[]uintptr:
 1785         fastpathTV.EncSliceUintptrV(*v, fastpathCheckNilTrue, e)
 1786 
 1787     case []int:
 1788         fastpathTV.EncSliceIntV(v, fastpathCheckNilTrue, e)
 1789     case *[]int:
 1790         fastpathTV.EncSliceIntV(*v, fastpathCheckNilTrue, e)
 1791 
 1792     case []int8:
 1793         fastpathTV.EncSliceInt8V(v, fastpathCheckNilTrue, e)
 1794     case *[]int8:
 1795         fastpathTV.EncSliceInt8V(*v, fastpathCheckNilTrue, e)
 1796 
 1797     case []int16:
 1798         fastpathTV.EncSliceInt16V(v, fastpathCheckNilTrue, e)
 1799     case *[]int16:
 1800         fastpathTV.EncSliceInt16V(*v, fastpathCheckNilTrue, e)
 1801 
 1802     case []int32:
 1803         fastpathTV.EncSliceInt32V(v, fastpathCheckNilTrue, e)
 1804     case *[]int32:
 1805         fastpathTV.EncSliceInt32V(*v, fastpathCheckNilTrue, e)
 1806 
 1807     case []int64:
 1808         fastpathTV.EncSliceInt64V(v, fastpathCheckNilTrue, e)
 1809     case *[]int64:
 1810         fastpathTV.EncSliceInt64V(*v, fastpathCheckNilTrue, e)
 1811 
 1812     case []bool:
 1813         fastpathTV.EncSliceBoolV(v, fastpathCheckNilTrue, e)
 1814     case *[]bool:
 1815         fastpathTV.EncSliceBoolV(*v, fastpathCheckNilTrue, e)
 1816 
 1817     default:
 1818         _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
 1819         return false
 1820     }
 1821     return true
 1822 }
 1823 
 1824 func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool {
 1825     switch v := iv.(type) {
 1826 
 1827     case map[interface{}]interface{}:
 1828         fastpathTV.EncMapIntfIntfV(v, fastpathCheckNilTrue, e)
 1829     case *map[interface{}]interface{}:
 1830         fastpathTV.EncMapIntfIntfV(*v, fastpathCheckNilTrue, e)
 1831 
 1832     case map[interface{}]string:
 1833         fastpathTV.EncMapIntfStringV(v, fastpathCheckNilTrue, e)
 1834     case *map[interface{}]string:
 1835         fastpathTV.EncMapIntfStringV(*v, fastpathCheckNilTrue, e)
 1836 
 1837     case map[interface{}]uint:
 1838         fastpathTV.EncMapIntfUintV(v, fastpathCheckNilTrue, e)
 1839     case *map[interface{}]uint:
 1840         fastpathTV.EncMapIntfUintV(*v, fastpathCheckNilTrue, e)
 1841 
 1842     case map[interface{}]uint8:
 1843         fastpathTV.EncMapIntfUint8V(v, fastpathCheckNilTrue, e)
 1844     case *map[interface{}]uint8:
 1845         fastpathTV.EncMapIntfUint8V(*v, fastpathCheckNilTrue, e)
 1846 
 1847     case map[interface{}]uint16:
 1848         fastpathTV.EncMapIntfUint16V(v, fastpathCheckNilTrue, e)
 1849     case *map[interface{}]uint16:
 1850         fastpathTV.EncMapIntfUint16V(*v, fastpathCheckNilTrue, e)
 1851 
 1852     case map[interface{}]uint32:
 1853         fastpathTV.EncMapIntfUint32V(v, fastpathCheckNilTrue, e)
 1854     case *map[interface{}]uint32:
 1855         fastpathTV.EncMapIntfUint32V(*v, fastpathCheckNilTrue, e)
 1856 
 1857     case map[interface{}]uint64:
 1858         fastpathTV.EncMapIntfUint64V(v, fastpathCheckNilTrue, e)
 1859     case *map[interface{}]uint64:
 1860         fastpathTV.EncMapIntfUint64V(*v, fastpathCheckNilTrue, e)
 1861 
 1862     case map[interface{}]uintptr:
 1863         fastpathTV.EncMapIntfUintptrV(v, fastpathCheckNilTrue, e)
 1864     case *map[interface{}]uintptr:
 1865         fastpathTV.EncMapIntfUintptrV(*v, fastpathCheckNilTrue, e)
 1866 
 1867     case map[interface{}]int:
 1868         fastpathTV.EncMapIntfIntV(v, fastpathCheckNilTrue, e)
 1869     case *map[interface{}]int:
 1870         fastpathTV.EncMapIntfIntV(*v, fastpathCheckNilTrue, e)
 1871 
 1872     case map[interface{}]int8:
 1873         fastpathTV.EncMapIntfInt8V(v, fastpathCheckNilTrue, e)
 1874     case *map[interface{}]int8:
 1875         fastpathTV.EncMapIntfInt8V(*v, fastpathCheckNilTrue, e)
 1876 
 1877     case map[interface{}]int16:
 1878         fastpathTV.EncMapIntfInt16V(v, fastpathCheckNilTrue, e)
 1879     case *map[interface{}]int16:
 1880         fastpathTV.EncMapIntfInt16V(*v, fastpathCheckNilTrue, e)
 1881 
 1882     case map[interface{}]int32:
 1883         fastpathTV.EncMapIntfInt32V(v, fastpathCheckNilTrue, e)
 1884     case *map[interface{}]int32:
 1885         fastpathTV.EncMapIntfInt32V(*v, fastpathCheckNilTrue, e)
 1886 
 1887     case map[interface{}]int64:
 1888         fastpathTV.EncMapIntfInt64V(v, fastpathCheckNilTrue, e)
 1889     case *map[interface{}]int64:
 1890         fastpathTV.EncMapIntfInt64V(*v, fastpathCheckNilTrue, e)
 1891 
 1892     case map[interface{}]float32:
 1893         fastpathTV.EncMapIntfFloat32V(v, fastpathCheckNilTrue, e)
 1894     case *map[interface{}]float32:
 1895         fastpathTV.EncMapIntfFloat32V(*v, fastpathCheckNilTrue, e)
 1896 
 1897     case map[interface{}]float64:
 1898         fastpathTV.EncMapIntfFloat64V(v, fastpathCheckNilTrue, e)
 1899     case *map[interface{}]float64:
 1900         fastpathTV.EncMapIntfFloat64V(*v, fastpathCheckNilTrue, e)
 1901 
 1902     case map[interface{}]bool:
 1903         fastpathTV.EncMapIntfBoolV(v, fastpathCheckNilTrue, e)
 1904     case *map[interface{}]bool:
 1905         fastpathTV.EncMapIntfBoolV(*v, fastpathCheckNilTrue, e)
 1906 
 1907     case map[string]interface{}:
 1908         fastpathTV.EncMapStringIntfV(v, fastpathCheckNilTrue, e)
 1909     case *map[string]interface{}:
 1910         fastpathTV.EncMapStringIntfV(*v, fastpathCheckNilTrue, e)
 1911 
 1912     case map[string]string:
 1913         fastpathTV.EncMapStringStringV(v, fastpathCheckNilTrue, e)
 1914     case *map[string]string:
 1915         fastpathTV.EncMapStringStringV(*v, fastpathCheckNilTrue, e)
 1916 
 1917     case map[string]uint:
 1918         fastpathTV.EncMapStringUintV(v, fastpathCheckNilTrue, e)
 1919     case *map[string]uint:
 1920         fastpathTV.EncMapStringUintV(*v, fastpathCheckNilTrue, e)
 1921 
 1922     case map[string]uint8:
 1923         fastpathTV.EncMapStringUint8V(v, fastpathCheckNilTrue, e)
 1924     case *map[string]uint8:
 1925         fastpathTV.EncMapStringUint8V(*v, fastpathCheckNilTrue, e)
 1926 
 1927     case map[string]uint16:
 1928         fastpathTV.EncMapStringUint16V(v, fastpathCheckNilTrue, e)
 1929     case *map[string]uint16:
 1930         fastpathTV.EncMapStringUint16V(*v, fastpathCheckNilTrue, e)
 1931 
 1932     case map[string]uint32:
 1933         fastpathTV.EncMapStringUint32V(v, fastpathCheckNilTrue, e)
 1934     case *map[string]uint32:
 1935         fastpathTV.EncMapStringUint32V(*v, fastpathCheckNilTrue, e)
 1936 
 1937     case map[string]uint64:
 1938         fastpathTV.EncMapStringUint64V(v, fastpathCheckNilTrue, e)
 1939     case *map[string]uint64:
 1940         fastpathTV.EncMapStringUint64V(*v, fastpathCheckNilTrue, e)
 1941 
 1942     case map[string]uintptr:
 1943         fastpathTV.EncMapStringUintptrV(v, fastpathCheckNilTrue, e)
 1944     case *map[string]uintptr:
 1945         fastpathTV.EncMapStringUintptrV(*v, fastpathCheckNilTrue, e)
 1946 
 1947     case map[string]int:
 1948         fastpathTV.EncMapStringIntV(v, fastpathCheckNilTrue, e)
 1949     case *map[string]int:
 1950         fastpathTV.EncMapStringIntV(*v, fastpathCheckNilTrue, e)
 1951 
 1952     case map[string]int8:
 1953         fastpathTV.EncMapStringInt8V(v, fastpathCheckNilTrue, e)
 1954     case *map[string]int8:
 1955         fastpathTV.EncMapStringInt8V(*v, fastpathCheckNilTrue, e)
 1956 
 1957     case map[string]int16:
 1958         fastpathTV.EncMapStringInt16V(v, fastpathCheckNilTrue, e)
 1959     case *map[string]int16:
 1960         fastpathTV.EncMapStringInt16V(*v, fastpathCheckNilTrue, e)
 1961 
 1962     case map[string]int32:
 1963         fastpathTV.EncMapStringInt32V(v, fastpathCheckNilTrue, e)
 1964     case *map[string]int32:
 1965         fastpathTV.EncMapStringInt32V(*v, fastpathCheckNilTrue, e)
 1966 
 1967     case map[string]int64:
 1968         fastpathTV.EncMapStringInt64V(v, fastpathCheckNilTrue, e)
 1969     case *map[string]int64:
 1970         fastpathTV.EncMapStringInt64V(*v, fastpathCheckNilTrue, e)
 1971 
 1972     case map[string]float32:
 1973         fastpathTV.EncMapStringFloat32V(v, fastpathCheckNilTrue, e)
 1974     case *map[string]float32:
 1975         fastpathTV.EncMapStringFloat32V(*v, fastpathCheckNilTrue, e)
 1976 
 1977     case map[string]float64:
 1978         fastpathTV.EncMapStringFloat64V(v, fastpathCheckNilTrue, e)
 1979     case *map[string]float64:
 1980         fastpathTV.EncMapStringFloat64V(*v, fastpathCheckNilTrue, e)
 1981 
 1982     case map[string]bool:
 1983         fastpathTV.EncMapStringBoolV(v, fastpathCheckNilTrue, e)
 1984     case *map[string]bool:
 1985         fastpathTV.EncMapStringBoolV(*v, fastpathCheckNilTrue, e)
 1986 
 1987     case map[float32]interface{}:
 1988         fastpathTV.EncMapFloat32IntfV(v, fastpathCheckNilTrue, e)
 1989     case *map[float32]interface{}:
 1990         fastpathTV.EncMapFloat32IntfV(*v, fastpathCheckNilTrue, e)
 1991 
 1992     case map[float32]string:
 1993         fastpathTV.EncMapFloat32StringV(v, fastpathCheckNilTrue, e)
 1994     case *map[float32]string:
 1995         fastpathTV.EncMapFloat32StringV(*v, fastpathCheckNilTrue, e)
 1996 
 1997     case map[float32]uint:
 1998         fastpathTV.EncMapFloat32UintV(v, fastpathCheckNilTrue, e)
 1999     case *map[float32]uint:
 2000         fastpathTV.EncMapFloat32UintV(*v, fastpathCheckNilTrue, e)
 2001 
 2002     case map[float32]uint8:
 2003         fastpathTV.EncMapFloat32Uint8V(v, fastpathCheckNilTrue, e)
 2004     case *map[float32]uint8:
 2005         fastpathTV.EncMapFloat32Uint8V(*v, fastpathCheckNilTrue, e)
 2006 
 2007     case map[float32]uint16:
 2008         fastpathTV.EncMapFloat32Uint16V(v, fastpathCheckNilTrue, e)
 2009     case *map[float32]uint16:
 2010         fastpathTV.EncMapFloat32Uint16V(*v, fastpathCheckNilTrue, e)
 2011 
 2012     case map[float32]uint32:
 2013         fastpathTV.EncMapFloat32Uint32V(v, fastpathCheckNilTrue, e)
 2014     case *map[float32]uint32:
 2015         fastpathTV.EncMapFloat32Uint32V(*v, fastpathCheckNilTrue, e)
 2016 
 2017     case map[float32]uint64:
 2018         fastpathTV.EncMapFloat32Uint64V(v, fastpathCheckNilTrue, e)
 2019     case *map[float32]uint64:
 2020         fastpathTV.EncMapFloat32Uint64V(*v, fastpathCheckNilTrue, e)
 2021 
 2022     case map[float32]uintptr:
 2023         fastpathTV.EncMapFloat32UintptrV(v, fastpathCheckNilTrue, e)
 2024     case *map[float32]uintptr:
 2025         fastpathTV.EncMapFloat32UintptrV(*v, fastpathCheckNilTrue, e)
 2026 
 2027     case map[float32]int:
 2028         fastpathTV.EncMapFloat32IntV(v, fastpathCheckNilTrue, e)
 2029     case *map[float32]int:
 2030         fastpathTV.EncMapFloat32IntV(*v, fastpathCheckNilTrue, e)
 2031 
 2032     case map[float32]int8:
 2033         fastpathTV.EncMapFloat32Int8V(v, fastpathCheckNilTrue, e)
 2034     case *map[float32]int8:
 2035         fastpathTV.EncMapFloat32Int8V(*v, fastpathCheckNilTrue, e)
 2036 
 2037     case map[float32]int16:
 2038         fastpathTV.EncMapFloat32Int16V(v, fastpathCheckNilTrue, e)
 2039     case *map[float32]int16:
 2040         fastpathTV.EncMapFloat32Int16V(*v, fastpathCheckNilTrue, e)
 2041 
 2042     case map[float32]int32:
 2043         fastpathTV.EncMapFloat32Int32V(v, fastpathCheckNilTrue, e)
 2044     case *map[float32]int32:
 2045         fastpathTV.EncMapFloat32Int32V(*v, fastpathCheckNilTrue, e)
 2046 
 2047     case map[float32]int64:
 2048         fastpathTV.EncMapFloat32Int64V(v, fastpathCheckNilTrue, e)
 2049     case *map[float32]int64:
 2050         fastpathTV.EncMapFloat32Int64V(*v, fastpathCheckNilTrue, e)
 2051 
 2052     case map[float32]float32:
 2053         fastpathTV.EncMapFloat32Float32V(v, fastpathCheckNilTrue, e)
 2054     case *map[float32]float32:
 2055         fastpathTV.EncMapFloat32Float32V(*v, fastpathCheckNilTrue, e)
 2056 
 2057     case map[float32]float64:
 2058         fastpathTV.EncMapFloat32Float64V(v, fastpathCheckNilTrue, e)
 2059     case *map[float32]float64:
 2060         fastpathTV.EncMapFloat32Float64V(*v, fastpathCheckNilTrue, e)
 2061 
 2062     case map[float32]bool:
 2063         fastpathTV.EncMapFloat32BoolV(v, fastpathCheckNilTrue, e)
 2064     case *map[float32]bool:
 2065         fastpathTV.EncMapFloat32BoolV(*v, fastpathCheckNilTrue, e)
 2066 
 2067     case map[float64]interface{}:
 2068         fastpathTV.EncMapFloat64IntfV(v, fastpathCheckNilTrue, e)
 2069     case *map[float64]interface{}:
 2070         fastpathTV.EncMapFloat64IntfV(*v, fastpathCheckNilTrue, e)
 2071 
 2072     case map[float64]string:
 2073         fastpathTV.EncMapFloat64StringV(v, fastpathCheckNilTrue, e)
 2074     case *map[float64]string:
 2075         fastpathTV.EncMapFloat64StringV(*v, fastpathCheckNilTrue, e)
 2076 
 2077     case map[float64]uint:
 2078         fastpathTV.EncMapFloat64UintV(v, fastpathCheckNilTrue, e)
 2079     case *map[float64]uint:
 2080         fastpathTV.EncMapFloat64UintV(*v, fastpathCheckNilTrue, e)
 2081 
 2082     case map[float64]uint8:
 2083         fastpathTV.EncMapFloat64Uint8V(v, fastpathCheckNilTrue, e)
 2084     case *map[float64]uint8:
 2085         fastpathTV.EncMapFloat64Uint8V(*v, fastpathCheckNilTrue, e)
 2086 
 2087     case map[float64]uint16:
 2088         fastpathTV.EncMapFloat64Uint16V(v, fastpathCheckNilTrue, e)
 2089     case *map[float64]uint16:
 2090         fastpathTV.EncMapFloat64Uint16V(*v, fastpathCheckNilTrue, e)
 2091 
 2092     case map[float64]uint32:
 2093         fastpathTV.EncMapFloat64Uint32V(v, fastpathCheckNilTrue, e)
 2094     case *map[float64]uint32:
 2095         fastpathTV.EncMapFloat64Uint32V(*v, fastpathCheckNilTrue, e)
 2096 
 2097     case map[float64]uint64:
 2098         fastpathTV.EncMapFloat64Uint64V(v, fastpathCheckNilTrue, e)
 2099     case *map[float64]uint64:
 2100         fastpathTV.EncMapFloat64Uint64V(*v, fastpathCheckNilTrue, e)
 2101 
 2102     case map[float64]uintptr:
 2103         fastpathTV.EncMapFloat64UintptrV(v, fastpathCheckNilTrue, e)
 2104     case *map[float64]uintptr:
 2105         fastpathTV.EncMapFloat64UintptrV(*v, fastpathCheckNilTrue, e)
 2106 
 2107     case map[float64]int:
 2108         fastpathTV.EncMapFloat64IntV(v, fastpathCheckNilTrue, e)
 2109     case *map[float64]int:
 2110         fastpathTV.EncMapFloat64IntV(*v, fastpathCheckNilTrue, e)
 2111 
 2112     case map[float64]int8:
 2113         fastpathTV.EncMapFloat64Int8V(v, fastpathCheckNilTrue, e)
 2114     case *map[float64]int8:
 2115         fastpathTV.EncMapFloat64Int8V(*v, fastpathCheckNilTrue, e)
 2116 
 2117     case map[float64]int16:
 2118         fastpathTV.EncMapFloat64Int16V(v, fastpathCheckNilTrue, e)
 2119     case *map[float64]int16:
 2120         fastpathTV.EncMapFloat64Int16V(*v, fastpathCheckNilTrue, e)
 2121 
 2122     case map[float64]int32:
 2123         fastpathTV.EncMapFloat64Int32V(v, fastpathCheckNilTrue, e)
 2124     case *map[float64]int32:
 2125         fastpathTV.EncMapFloat64Int32V(*v, fastpathCheckNilTrue, e)
 2126 
 2127     case map[float64]int64:
 2128         fastpathTV.EncMapFloat64Int64V(v, fastpathCheckNilTrue, e)
 2129     case *map[float64]int64:
 2130         fastpathTV.EncMapFloat64Int64V(*v, fastpathCheckNilTrue, e)
 2131 
 2132     case map[float64]float32:
 2133         fastpathTV.EncMapFloat64Float32V(v, fastpathCheckNilTrue, e)
 2134     case *map[float64]float32:
 2135         fastpathTV.EncMapFloat64Float32V(*v, fastpathCheckNilTrue, e)
 2136 
 2137     case map[float64]float64:
 2138         fastpathTV.EncMapFloat64Float64V(v, fastpathCheckNilTrue, e)
 2139     case *map[float64]float64:
 2140         fastpathTV.EncMapFloat64Float64V(*v, fastpathCheckNilTrue, e)
 2141 
 2142     case map[float64]bool:
 2143         fastpathTV.EncMapFloat64BoolV(v, fastpathCheckNilTrue, e)
 2144     case *map[float64]bool:
 2145         fastpathTV.EncMapFloat64BoolV(*v, fastpathCheckNilTrue, e)
 2146 
 2147     case map[uint]interface{}:
 2148         fastpathTV.EncMapUintIntfV(v, fastpathCheckNilTrue, e)
 2149     case *map[uint]interface{}:
 2150         fastpathTV.EncMapUintIntfV(*v, fastpathCheckNilTrue, e)
 2151 
 2152     case map[uint]string:
 2153         fastpathTV.EncMapUintStringV(v, fastpathCheckNilTrue, e)
 2154     case *map[uint]string:
 2155         fastpathTV.EncMapUintStringV(*v, fastpathCheckNilTrue, e)
 2156 
 2157     case map[uint]uint:
 2158         fastpathTV.EncMapUintUintV(v, fastpathCheckNilTrue, e)
 2159     case *map[uint]uint:
 2160         fastpathTV.EncMapUintUintV(*v, fastpathCheckNilTrue, e)
 2161 
 2162     case map[uint]uint8:
 2163         fastpathTV.EncMapUintUint8V(v, fastpathCheckNilTrue, e)
 2164     case *map[uint]uint8:
 2165         fastpathTV.EncMapUintUint8V(*v, fastpathCheckNilTrue, e)
 2166 
 2167     case map[uint]uint16:
 2168         fastpathTV.EncMapUintUint16V(v, fastpathCheckNilTrue, e)
 2169     case *map[uint]uint16:
 2170         fastpathTV.EncMapUintUint16V(*v, fastpathCheckNilTrue, e)
 2171 
 2172     case map[uint]uint32:
 2173         fastpathTV.EncMapUintUint32V(v, fastpathCheckNilTrue, e)
 2174     case *map[uint]uint32:
 2175         fastpathTV.EncMapUintUint32V(*v, fastpathCheckNilTrue, e)
 2176 
 2177     case map[uint]uint64:
 2178         fastpathTV.EncMapUintUint64V(v, fastpathCheckNilTrue, e)
 2179     case *map[uint]uint64:
 2180         fastpathTV.EncMapUintUint64V(*v, fastpathCheckNilTrue, e)
 2181 
 2182     case map[uint]uintptr:
 2183         fastpathTV.EncMapUintUintptrV(v, fastpathCheckNilTrue, e)
 2184     case *map[uint]uintptr:
 2185         fastpathTV.EncMapUintUintptrV(*v, fastpathCheckNilTrue, e)
 2186 
 2187     case map[uint]int:
 2188         fastpathTV.EncMapUintIntV(v, fastpathCheckNilTrue, e)
 2189     case *map[uint]int:
 2190         fastpathTV.EncMapUintIntV(*v, fastpathCheckNilTrue, e)
 2191 
 2192     case map[uint]int8:
 2193         fastpathTV.EncMapUintInt8V(v, fastpathCheckNilTrue, e)
 2194     case *map[uint]int8:
 2195         fastpathTV.EncMapUintInt8V(*v, fastpathCheckNilTrue, e)
 2196 
 2197     case map[uint]int16:
 2198         fastpathTV.EncMapUintInt16V(v, fastpathCheckNilTrue, e)
 2199     case *map[uint]int16:
 2200         fastpathTV.EncMapUintInt16V(*v, fastpathCheckNilTrue, e)
 2201 
 2202     case map[uint]int32:
 2203         fastpathTV.EncMapUintInt32V(v, fastpathCheckNilTrue, e)
 2204     case *map[uint]int32:
 2205         fastpathTV.EncMapUintInt32V(*v, fastpathCheckNilTrue, e)
 2206 
 2207     case map[uint]int64:
 2208         fastpathTV.EncMapUintInt64V(v, fastpathCheckNilTrue, e)
 2209     case *map[uint]int64:
 2210         fastpathTV.EncMapUintInt64V(*v, fastpathCheckNilTrue, e)
 2211 
 2212     case map[uint]float32:
 2213         fastpathTV.EncMapUintFloat32V(v, fastpathCheckNilTrue, e)
 2214     case *map[uint]float32:
 2215         fastpathTV.EncMapUintFloat32V(*v, fastpathCheckNilTrue, e)
 2216 
 2217     case map[uint]float64:
 2218         fastpathTV.EncMapUintFloat64V(v, fastpathCheckNilTrue, e)
 2219     case *map[uint]float64:
 2220         fastpathTV.EncMapUintFloat64V(*v, fastpathCheckNilTrue, e)
 2221 
 2222     case map[uint]bool:
 2223         fastpathTV.EncMapUintBoolV(v, fastpathCheckNilTrue, e)
 2224     case *map[uint]bool:
 2225         fastpathTV.EncMapUintBoolV(*v, fastpathCheckNilTrue, e)
 2226 
 2227     case map[uint8]interface{}:
 2228         fastpathTV.EncMapUint8IntfV(v, fastpathCheckNilTrue, e)
 2229     case *map[uint8]interface{}:
 2230         fastpathTV.EncMapUint8IntfV(*v, fastpathCheckNilTrue, e)
 2231 
 2232     case map[uint8]string:
 2233         fastpathTV.EncMapUint8StringV(v, fastpathCheckNilTrue, e)
 2234     case *map[uint8]string:
 2235         fastpathTV.EncMapUint8StringV(*v, fastpathCheckNilTrue, e)
 2236 
 2237     case map[uint8]uint:
 2238         fastpathTV.EncMapUint8UintV(v, fastpathCheckNilTrue, e)
 2239     case *map[uint8]uint:
 2240         fastpathTV.EncMapUint8UintV(*v, fastpathCheckNilTrue, e)
 2241 
 2242     case map[uint8]uint8:
 2243         fastpathTV.EncMapUint8Uint8V(v, fastpathCheckNilTrue, e)
 2244     case *map[uint8]uint8:
 2245         fastpathTV.EncMapUint8Uint8V(*v, fastpathCheckNilTrue, e)
 2246 
 2247     case map[uint8]uint16:
 2248         fastpathTV.EncMapUint8Uint16V(v, fastpathCheckNilTrue, e)
 2249     case *map[uint8]uint16:
 2250         fastpathTV.EncMapUint8Uint16V(*v, fastpathCheckNilTrue, e)
 2251 
 2252     case map[uint8]uint32:
 2253         fastpathTV.EncMapUint8Uint32V(v, fastpathCheckNilTrue, e)
 2254     case *map[uint8]uint32:
 2255         fastpathTV.EncMapUint8Uint32V(*v, fastpathCheckNilTrue, e)
 2256 
 2257     case map[uint8]uint64:
 2258         fastpathTV.EncMapUint8Uint64V(v, fastpathCheckNilTrue, e)
 2259     case *map[uint8]uint64:
 2260         fastpathTV.EncMapUint8Uint64V(*v, fastpathCheckNilTrue, e)
 2261 
 2262     case map[uint8]uintptr:
 2263         fastpathTV.EncMapUint8UintptrV(v, fastpathCheckNilTrue, e)
 2264     case *map[uint8]uintptr:
 2265         fastpathTV.EncMapUint8UintptrV(*v, fastpathCheckNilTrue, e)
 2266 
 2267     case map[uint8]int:
 2268         fastpathTV.EncMapUint8IntV(v, fastpathCheckNilTrue, e)
 2269     case *map[uint8]int:
 2270         fastpathTV.EncMapUint8IntV(*v, fastpathCheckNilTrue, e)
 2271 
 2272     case map[uint8]int8:
 2273         fastpathTV.EncMapUint8Int8V(v, fastpathCheckNilTrue, e)
 2274     case *map[uint8]int8:
 2275         fastpathTV.EncMapUint8Int8V(*v, fastpathCheckNilTrue, e)
 2276 
 2277     case map[uint8]int16:
 2278         fastpathTV.EncMapUint8Int16V(v, fastpathCheckNilTrue, e)
 2279     case *map[uint8]int16:
 2280         fastpathTV.EncMapUint8Int16V(*v, fastpathCheckNilTrue, e)
 2281 
 2282     case map[uint8]int32:
 2283         fastpathTV.EncMapUint8Int32V(v, fastpathCheckNilTrue, e)
 2284     case *map[uint8]int32:
 2285         fastpathTV.EncMapUint8Int32V(*v, fastpathCheckNilTrue, e)
 2286 
 2287     case map[uint8]int64:
 2288         fastpathTV.EncMapUint8Int64V(v, fastpathCheckNilTrue, e)
 2289     case *map[uint8]int64:
 2290         fastpathTV.EncMapUint8Int64V(*v, fastpathCheckNilTrue, e)
 2291 
 2292     case map[uint8]float32:
 2293         fastpathTV.EncMapUint8Float32V(v, fastpathCheckNilTrue, e)
 2294     case *map[uint8]float32:
 2295         fastpathTV.EncMapUint8Float32V(*v, fastpathCheckNilTrue, e)
 2296 
 2297     case map[uint8]float64:
 2298         fastpathTV.EncMapUint8Float64V(v, fastpathCheckNilTrue, e)
 2299     case *map[uint8]float64:
 2300         fastpathTV.EncMapUint8Float64V(*v, fastpathCheckNilTrue, e)
 2301 
 2302     case map[uint8]bool:
 2303         fastpathTV.EncMapUint8BoolV(v, fastpathCheckNilTrue, e)
 2304     case *map[uint8]bool:
 2305         fastpathTV.EncMapUint8BoolV(*v, fastpathCheckNilTrue, e)
 2306 
 2307     case map[uint16]interface{}:
 2308         fastpathTV.EncMapUint16IntfV(v, fastpathCheckNilTrue, e)
 2309     case *map[uint16]interface{}:
 2310         fastpathTV.EncMapUint16IntfV(*v, fastpathCheckNilTrue, e)
 2311 
 2312     case map[uint16]string:
 2313         fastpathTV.EncMapUint16StringV(v, fastpathCheckNilTrue, e)
 2314     case *map[uint16]string:
 2315         fastpathTV.EncMapUint16StringV(*v, fastpathCheckNilTrue, e)
 2316 
 2317     case map[uint16]uint:
 2318         fastpathTV.EncMapUint16UintV(v, fastpathCheckNilTrue, e)
 2319     case *map[uint16]uint:
 2320         fastpathTV.EncMapUint16UintV(*v, fastpathCheckNilTrue, e)
 2321 
 2322     case map[uint16]uint8:
 2323         fastpathTV.EncMapUint16Uint8V(v, fastpathCheckNilTrue, e)
 2324     case *map[uint16]uint8:
 2325         fastpathTV.EncMapUint16Uint8V(*v, fastpathCheckNilTrue, e)
 2326 
 2327     case map[uint16]uint16:
 2328         fastpathTV.EncMapUint16Uint16V(v, fastpathCheckNilTrue, e)
 2329     case *map[uint16]uint16:
 2330         fastpathTV.EncMapUint16Uint16V(*v, fastpathCheckNilTrue, e)
 2331 
 2332     case map[uint16]uint32:
 2333         fastpathTV.EncMapUint16Uint32V(v, fastpathCheckNilTrue, e)
 2334     case *map[uint16]uint32:
 2335         fastpathTV.EncMapUint16Uint32V(*v, fastpathCheckNilTrue, e)
 2336 
 2337     case map[uint16]uint64:
 2338         fastpathTV.EncMapUint16Uint64V(v, fastpathCheckNilTrue, e)
 2339     case *map[uint16]uint64:
 2340         fastpathTV.EncMapUint16Uint64V(*v, fastpathCheckNilTrue, e)
 2341 
 2342     case map[uint16]uintptr:
 2343         fastpathTV.EncMapUint16UintptrV(v, fastpathCheckNilTrue, e)
 2344     case *map[uint16]uintptr:
 2345         fastpathTV.EncMapUint16UintptrV(*v, fastpathCheckNilTrue, e)
 2346 
 2347     case map[uint16]int:
 2348         fastpathTV.EncMapUint16IntV(v, fastpathCheckNilTrue, e)
 2349     case *map[uint16]int:
 2350         fastpathTV.EncMapUint16IntV(*v, fastpathCheckNilTrue, e)
 2351 
 2352     case map[uint16]int8:
 2353         fastpathTV.EncMapUint16Int8V(v, fastpathCheckNilTrue, e)
 2354     case *map[uint16]int8:
 2355         fastpathTV.EncMapUint16Int8V(*v, fastpathCheckNilTrue, e)
 2356 
 2357     case map[uint16]int16:
 2358         fastpathTV.EncMapUint16Int16V(v, fastpathCheckNilTrue, e)
 2359     case *map[uint16]int16:
 2360         fastpathTV.EncMapUint16Int16V(*v, fastpathCheckNilTrue, e)
 2361 
 2362     case map[uint16]int32:
 2363         fastpathTV.EncMapUint16Int32V(v, fastpathCheckNilTrue, e)
 2364     case *map[uint16]int32:
 2365         fastpathTV.EncMapUint16Int32V(*v, fastpathCheckNilTrue, e)
 2366 
 2367     case map[uint16]int64:
 2368         fastpathTV.EncMapUint16Int64V(v, fastpathCheckNilTrue, e)
 2369     case *map[uint16]int64:
 2370         fastpathTV.EncMapUint16Int64V(*v, fastpathCheckNilTrue, e)
 2371 
 2372     case map[uint16]float32:
 2373         fastpathTV.EncMapUint16Float32V(v, fastpathCheckNilTrue, e)
 2374     case *map[uint16]float32:
 2375         fastpathTV.EncMapUint16Float32V(*v, fastpathCheckNilTrue, e)
 2376 
 2377     case map[uint16]float64:
 2378         fastpathTV.EncMapUint16Float64V(v, fastpathCheckNilTrue, e)
 2379     case *map[uint16]float64:
 2380         fastpathTV.EncMapUint16Float64V(*v, fastpathCheckNilTrue, e)
 2381 
 2382     case map[uint16]bool:
 2383         fastpathTV.EncMapUint16BoolV(v, fastpathCheckNilTrue, e)
 2384     case *map[uint16]bool:
 2385         fastpathTV.EncMapUint16BoolV(*v, fastpathCheckNilTrue, e)
 2386 
 2387     case map[uint32]interface{}:
 2388         fastpathTV.EncMapUint32IntfV(v, fastpathCheckNilTrue, e)
 2389     case *map[uint32]interface{}:
 2390         fastpathTV.EncMapUint32IntfV(*v, fastpathCheckNilTrue, e)
 2391 
 2392     case map[uint32]string:
 2393         fastpathTV.EncMapUint32StringV(v, fastpathCheckNilTrue, e)
 2394     case *map[uint32]string:
 2395         fastpathTV.EncMapUint32StringV(*v, fastpathCheckNilTrue, e)
 2396 
 2397     case map[uint32]uint:
 2398         fastpathTV.EncMapUint32UintV(v, fastpathCheckNilTrue, e)
 2399     case *map[uint32]uint:
 2400         fastpathTV.EncMapUint32UintV(*v, fastpathCheckNilTrue, e)
 2401 
 2402     case map[uint32]uint8:
 2403         fastpathTV.EncMapUint32Uint8V(v, fastpathCheckNilTrue, e)
 2404     case *map[uint32]uint8:
 2405         fastpathTV.EncMapUint32Uint8V(*v, fastpathCheckNilTrue, e)
 2406 
 2407     case map[uint32]uint16:
 2408         fastpathTV.EncMapUint32Uint16V(v, fastpathCheckNilTrue, e)
 2409     case *map[uint32]uint16:
 2410         fastpathTV.EncMapUint32Uint16V(*v, fastpathCheckNilTrue, e)
 2411 
 2412     case map[uint32]uint32:
 2413         fastpathTV.EncMapUint32Uint32V(v, fastpathCheckNilTrue, e)
 2414     case *map[uint32]uint32:
 2415         fastpathTV.EncMapUint32Uint32V(*v, fastpathCheckNilTrue, e)
 2416 
 2417     case map[uint32]uint64:
 2418         fastpathTV.EncMapUint32Uint64V(v, fastpathCheckNilTrue, e)
 2419     case *map[uint32]uint64:
 2420         fastpathTV.EncMapUint32Uint64V(*v, fastpathCheckNilTrue, e)
 2421 
 2422     case map[uint32]uintptr:
 2423         fastpathTV.EncMapUint32UintptrV(v, fastpathCheckNilTrue, e)
 2424     case *map[uint32]uintptr:
 2425         fastpathTV.EncMapUint32UintptrV(*v, fastpathCheckNilTrue, e)
 2426 
 2427     case map[uint32]int:
 2428         fastpathTV.EncMapUint32IntV(v, fastpathCheckNilTrue, e)
 2429     case *map[uint32]int:
 2430         fastpathTV.EncMapUint32IntV(*v, fastpathCheckNilTrue, e)
 2431 
 2432     case map[uint32]int8:
 2433         fastpathTV.EncMapUint32Int8V(v, fastpathCheckNilTrue, e)
 2434     case *map[uint32]int8:
 2435         fastpathTV.EncMapUint32Int8V(*v, fastpathCheckNilTrue, e)
 2436 
 2437     case map[uint32]int16:
 2438         fastpathTV.EncMapUint32Int16V(v, fastpathCheckNilTrue, e)
 2439     case *map[uint32]int16:
 2440         fastpathTV.EncMapUint32Int16V(*v, fastpathCheckNilTrue, e)
 2441 
 2442     case map[uint32]int32:
 2443         fastpathTV.EncMapUint32Int32V(v, fastpathCheckNilTrue, e)
 2444     case *map[uint32]int32:
 2445         fastpathTV.EncMapUint32Int32V(*v, fastpathCheckNilTrue, e)
 2446 
 2447     case map[uint32]int64:
 2448         fastpathTV.EncMapUint32Int64V(v, fastpathCheckNilTrue, e)
 2449     case *map[uint32]int64:
 2450         fastpathTV.EncMapUint32Int64V(*v, fastpathCheckNilTrue, e)
 2451 
 2452     case map[uint32]float32:
 2453         fastpathTV.EncMapUint32Float32V(v, fastpathCheckNilTrue, e)
 2454     case *map[uint32]float32:
 2455         fastpathTV.EncMapUint32Float32V(*v, fastpathCheckNilTrue, e)
 2456 
 2457     case map[uint32]float64:
 2458         fastpathTV.EncMapUint32Float64V(v, fastpathCheckNilTrue, e)
 2459     case *map[uint32]float64:
 2460         fastpathTV.EncMapUint32Float64V(*v, fastpathCheckNilTrue, e)
 2461 
 2462     case map[uint32]bool:
 2463         fastpathTV.EncMapUint32BoolV(v, fastpathCheckNilTrue, e)
 2464     case *map[uint32]bool:
 2465         fastpathTV.EncMapUint32BoolV(*v, fastpathCheckNilTrue, e)
 2466 
 2467     case map[uint64]interface{}:
 2468         fastpathTV.EncMapUint64IntfV(v, fastpathCheckNilTrue, e)
 2469     case *map[uint64]interface{}:
 2470         fastpathTV.EncMapUint64IntfV(*v, fastpathCheckNilTrue, e)
 2471 
 2472     case map[uint64]string:
 2473         fastpathTV.EncMapUint64StringV(v, fastpathCheckNilTrue, e)
 2474     case *map[uint64]string:
 2475         fastpathTV.EncMapUint64StringV(*v, fastpathCheckNilTrue, e)
 2476 
 2477     case map[uint64]uint:
 2478         fastpathTV.EncMapUint64UintV(v, fastpathCheckNilTrue, e)
 2479     case *map[uint64]uint:
 2480         fastpathTV.EncMapUint64UintV(*v, fastpathCheckNilTrue, e)
 2481 
 2482     case map[uint64]uint8:
 2483         fastpathTV.EncMapUint64Uint8V(v, fastpathCheckNilTrue, e)
 2484     case *map[uint64]uint8:
 2485         fastpathTV.EncMapUint64Uint8V(*v, fastpathCheckNilTrue, e)
 2486 
 2487     case map[uint64]uint16:
 2488         fastpathTV.EncMapUint64Uint16V(v, fastpathCheckNilTrue, e)
 2489     case *map[uint64]uint16:
 2490         fastpathTV.EncMapUint64Uint16V(*v, fastpathCheckNilTrue, e)
 2491 
 2492     case map[uint64]uint32:
 2493         fastpathTV.EncMapUint64Uint32V(v, fastpathCheckNilTrue, e)
 2494     case *map[uint64]uint32:
 2495         fastpathTV.EncMapUint64Uint32V(*v, fastpathCheckNilTrue, e)
 2496 
 2497     case map[uint64]uint64:
 2498         fastpathTV.EncMapUint64Uint64V(v, fastpathCheckNilTrue, e)
 2499     case *map[uint64]uint64:
 2500         fastpathTV.EncMapUint64Uint64V(*v, fastpathCheckNilTrue, e)
 2501 
 2502     case map[uint64]uintptr:
 2503         fastpathTV.EncMapUint64UintptrV(v, fastpathCheckNilTrue, e)
 2504     case *map[uint64]uintptr:
 2505         fastpathTV.EncMapUint64UintptrV(*v, fastpathCheckNilTrue, e)
 2506 
 2507     case map[uint64]int:
 2508         fastpathTV.EncMapUint64IntV(v, fastpathCheckNilTrue, e)
 2509     case *map[uint64]int:
 2510         fastpathTV.EncMapUint64IntV(*v, fastpathCheckNilTrue, e)
 2511 
 2512     case map[uint64]int8:
 2513         fastpathTV.EncMapUint64Int8V(v, fastpathCheckNilTrue, e)
 2514     case *map[uint64]int8:
 2515         fastpathTV.EncMapUint64Int8V(*v, fastpathCheckNilTrue, e)
 2516 
 2517     case map[uint64]int16:
 2518         fastpathTV.EncMapUint64Int16V(v, fastpathCheckNilTrue, e)
 2519     case *map[uint64]int16:
 2520         fastpathTV.EncMapUint64Int16V(*v, fastpathCheckNilTrue, e)
 2521 
 2522     case map[uint64]int32:
 2523         fastpathTV.EncMapUint64Int32V(v, fastpathCheckNilTrue, e)
 2524     case *map[uint64]int32:
 2525         fastpathTV.EncMapUint64Int32V(*v, fastpathCheckNilTrue, e)
 2526 
 2527     case map[uint64]int64:
 2528         fastpathTV.EncMapUint64Int64V(v, fastpathCheckNilTrue, e)
 2529     case *map[uint64]int64:
 2530         fastpathTV.EncMapUint64Int64V(*v, fastpathCheckNilTrue, e)
 2531 
 2532     case map[uint64]float32:
 2533         fastpathTV.EncMapUint64Float32V(v, fastpathCheckNilTrue, e)
 2534     case *map[uint64]float32:
 2535         fastpathTV.EncMapUint64Float32V(*v, fastpathCheckNilTrue, e)
 2536 
 2537     case map[uint64]float64:
 2538         fastpathTV.EncMapUint64Float64V(v, fastpathCheckNilTrue, e)
 2539     case *map[uint64]float64:
 2540         fastpathTV.EncMapUint64Float64V(*v, fastpathCheckNilTrue, e)
 2541 
 2542     case map[uint64]bool:
 2543         fastpathTV.EncMapUint64BoolV(v, fastpathCheckNilTrue, e)
 2544     case *map[uint64]bool:
 2545         fastpathTV.EncMapUint64BoolV(*v, fastpathCheckNilTrue, e)
 2546 
 2547     case map[uintptr]interface{}:
 2548         fastpathTV.EncMapUintptrIntfV(v, fastpathCheckNilTrue, e)
 2549     case *map[uintptr]interface{}:
 2550         fastpathTV.EncMapUintptrIntfV(*v, fastpathCheckNilTrue, e)
 2551 
 2552     case map[uintptr]string:
 2553         fastpathTV.EncMapUintptrStringV(v, fastpathCheckNilTrue, e)
 2554     case *map[uintptr]string:
 2555         fastpathTV.EncMapUintptrStringV(*v, fastpathCheckNilTrue, e)
 2556 
 2557     case map[uintptr]uint:
 2558         fastpathTV.EncMapUintptrUintV(v, fastpathCheckNilTrue, e)
 2559     case *map[uintptr]uint:
 2560         fastpathTV.EncMapUintptrUintV(*v, fastpathCheckNilTrue, e)
 2561 
 2562     case map[uintptr]uint8:
 2563         fastpathTV.EncMapUintptrUint8V(v, fastpathCheckNilTrue, e)
 2564     case *map[uintptr]uint8:
 2565         fastpathTV.EncMapUintptrUint8V(*v, fastpathCheckNilTrue, e)
 2566 
 2567     case map[uintptr]uint16:
 2568         fastpathTV.EncMapUintptrUint16V(v, fastpathCheckNilTrue, e)
 2569     case *map[uintptr]uint16:
 2570         fastpathTV.EncMapUintptrUint16V(*v, fastpathCheckNilTrue, e)
 2571 
 2572     case map[uintptr]uint32:
 2573         fastpathTV.EncMapUintptrUint32V(v, fastpathCheckNilTrue, e)
 2574     case *map[uintptr]uint32:
 2575         fastpathTV.EncMapUintptrUint32V(*v, fastpathCheckNilTrue, e)
 2576 
 2577     case map[uintptr]uint64:
 2578         fastpathTV.EncMapUintptrUint64V(v, fastpathCheckNilTrue, e)
 2579     case *map[uintptr]uint64:
 2580         fastpathTV.EncMapUintptrUint64V(*v, fastpathCheckNilTrue, e)
 2581 
 2582     case map[uintptr]uintptr:
 2583         fastpathTV.EncMapUintptrUintptrV(v, fastpathCheckNilTrue, e)
 2584     case *map[uintptr]uintptr:
 2585         fastpathTV.EncMapUintptrUintptrV(*v, fastpathCheckNilTrue, e)
 2586 
 2587     case map[uintptr]int:
 2588         fastpathTV.EncMapUintptrIntV(v, fastpathCheckNilTrue, e)
 2589     case *map[uintptr]int:
 2590         fastpathTV.EncMapUintptrIntV(*v, fastpathCheckNilTrue, e)
 2591 
 2592     case map[uintptr]int8:
 2593         fastpathTV.EncMapUintptrInt8V(v, fastpathCheckNilTrue, e)
 2594     case *map[uintptr]int8:
 2595         fastpathTV.EncMapUintptrInt8V(*v, fastpathCheckNilTrue, e)
 2596 
 2597     case map[uintptr]int16:
 2598         fastpathTV.EncMapUintptrInt16V(v, fastpathCheckNilTrue, e)
 2599     case *map[uintptr]int16:
 2600         fastpathTV.EncMapUintptrInt16V(*v, fastpathCheckNilTrue, e)
 2601 
 2602     case map[uintptr]int32:
 2603         fastpathTV.EncMapUintptrInt32V(v, fastpathCheckNilTrue, e)
 2604     case *map[uintptr]int32:
 2605         fastpathTV.EncMapUintptrInt32V(*v, fastpathCheckNilTrue, e)
 2606 
 2607     case map[uintptr]int64:
 2608         fastpathTV.EncMapUintptrInt64V(v, fastpathCheckNilTrue, e)
 2609     case *map[uintptr]int64:
 2610         fastpathTV.EncMapUintptrInt64V(*v, fastpathCheckNilTrue, e)
 2611 
 2612     case map[uintptr]float32:
 2613         fastpathTV.EncMapUintptrFloat32V(v, fastpathCheckNilTrue, e)
 2614     case *map[uintptr]float32:
 2615         fastpathTV.EncMapUintptrFloat32V(*v, fastpathCheckNilTrue, e)
 2616 
 2617     case map[uintptr]float64:
 2618         fastpathTV.EncMapUintptrFloat64V(v, fastpathCheckNilTrue, e)
 2619     case *map[uintptr]float64:
 2620         fastpathTV.EncMapUintptrFloat64V(*v, fastpathCheckNilTrue, e)
 2621 
 2622     case map[uintptr]bool:
 2623         fastpathTV.EncMapUintptrBoolV(v, fastpathCheckNilTrue, e)
 2624     case *map[uintptr]bool:
 2625         fastpathTV.EncMapUintptrBoolV(*v, fastpathCheckNilTrue, e)
 2626 
 2627     case map[int]interface{}:
 2628         fastpathTV.EncMapIntIntfV(v, fastpathCheckNilTrue, e)
 2629     case *map[int]interface{}:
 2630         fastpathTV.EncMapIntIntfV(*v, fastpathCheckNilTrue, e)
 2631 
 2632     case map[int]string:
 2633         fastpathTV.EncMapIntStringV(v, fastpathCheckNilTrue, e)
 2634     case *map[int]string:
 2635         fastpathTV.EncMapIntStringV(*v, fastpathCheckNilTrue, e)
 2636 
 2637     case map[int]uint:
 2638         fastpathTV.EncMapIntUintV(v, fastpathCheckNilTrue, e)
 2639     case *map[int]uint:
 2640         fastpathTV.EncMapIntUintV(*v, fastpathCheckNilTrue, e)
 2641 
 2642     case map[int]uint8:
 2643         fastpathTV.EncMapIntUint8V(v, fastpathCheckNilTrue, e)
 2644     case *map[int]uint8:
 2645         fastpathTV.EncMapIntUint8V(*v, fastpathCheckNilTrue, e)
 2646 
 2647     case map[int]uint16:
 2648         fastpathTV.EncMapIntUint16V(v, fastpathCheckNilTrue, e)
 2649     case *map[int]uint16:
 2650         fastpathTV.EncMapIntUint16V(*v, fastpathCheckNilTrue, e)
 2651 
 2652     case map[int]uint32:
 2653         fastpathTV.EncMapIntUint32V(v, fastpathCheckNilTrue, e)
 2654     case *map[int]uint32:
 2655         fastpathTV.EncMapIntUint32V(*v, fastpathCheckNilTrue, e)
 2656 
 2657     case map[int]uint64:
 2658         fastpathTV.EncMapIntUint64V(v, fastpathCheckNilTrue, e)
 2659     case *map[int]uint64:
 2660         fastpathTV.EncMapIntUint64V(*v, fastpathCheckNilTrue, e)
 2661 
 2662     case map[int]uintptr:
 2663         fastpathTV.EncMapIntUintptrV(v, fastpathCheckNilTrue, e)
 2664     case *map[int]uintptr:
 2665         fastpathTV.EncMapIntUintptrV(*v, fastpathCheckNilTrue, e)
 2666 
 2667     case map[int]int:
 2668         fastpathTV.EncMapIntIntV(v, fastpathCheckNilTrue, e)
 2669     case *map[int]int:
 2670         fastpathTV.EncMapIntIntV(*v, fastpathCheckNilTrue, e)
 2671 
 2672     case map[int]int8:
 2673         fastpathTV.EncMapIntInt8V(v, fastpathCheckNilTrue, e)
 2674     case *map[int]int8:
 2675         fastpathTV.EncMapIntInt8V(*v, fastpathCheckNilTrue, e)
 2676 
 2677     case map[int]int16:
 2678         fastpathTV.EncMapIntInt16V(v, fastpathCheckNilTrue, e)
 2679     case *map[int]int16:
 2680         fastpathTV.EncMapIntInt16V(*v, fastpathCheckNilTrue, e)
 2681 
 2682     case map[int]int32:
 2683         fastpathTV.EncMapIntInt32V(v, fastpathCheckNilTrue, e)
 2684     case *map[int]int32:
 2685         fastpathTV.EncMapIntInt32V(*v, fastpathCheckNilTrue, e)
 2686 
 2687     case map[int]int64:
 2688         fastpathTV.EncMapIntInt64V(v, fastpathCheckNilTrue, e)
 2689     case *map[int]int64:
 2690         fastpathTV.EncMapIntInt64V(*v, fastpathCheckNilTrue, e)
 2691 
 2692     case map[int]float32:
 2693         fastpathTV.EncMapIntFloat32V(v, fastpathCheckNilTrue, e)
 2694     case *map[int]float32:
 2695         fastpathTV.EncMapIntFloat32V(*v, fastpathCheckNilTrue, e)
 2696 
 2697     case map[int]float64:
 2698         fastpathTV.EncMapIntFloat64V(v, fastpathCheckNilTrue, e)
 2699     case *map[int]float64:
 2700         fastpathTV.EncMapIntFloat64V(*v, fastpathCheckNilTrue, e)
 2701 
 2702     case map[int]bool:
 2703         fastpathTV.EncMapIntBoolV(v, fastpathCheckNilTrue, e)
 2704     case *map[int]bool:
 2705         fastpathTV.EncMapIntBoolV(*v, fastpathCheckNilTrue, e)
 2706 
 2707     case map[int8]interface{}:
 2708         fastpathTV.EncMapInt8IntfV(v, fastpathCheckNilTrue, e)
 2709     case *map[int8]interface{}:
 2710         fastpathTV.EncMapInt8IntfV(*v, fastpathCheckNilTrue, e)
 2711 
 2712     case map[int8]string:
 2713         fastpathTV.EncMapInt8StringV(v, fastpathCheckNilTrue, e)
 2714     case *map[int8]string:
 2715         fastpathTV.EncMapInt8StringV(*v, fastpathCheckNilTrue, e)
 2716 
 2717     case map[int8]uint:
 2718         fastpathTV.EncMapInt8UintV(v, fastpathCheckNilTrue, e)
 2719     case *map[int8]uint:
 2720         fastpathTV.EncMapInt8UintV(*v, fastpathCheckNilTrue, e)
 2721 
 2722     case map[int8]uint8:
 2723         fastpathTV.EncMapInt8Uint8V(v, fastpathCheckNilTrue, e)
 2724     case *map[int8]uint8:
 2725         fastpathTV.EncMapInt8Uint8V(*v, fastpathCheckNilTrue, e)
 2726 
 2727     case map[int8]uint16:
 2728         fastpathTV.EncMapInt8Uint16V(v, fastpathCheckNilTrue, e)
 2729     case *map[int8]uint16:
 2730         fastpathTV.EncMapInt8Uint16V(*v, fastpathCheckNilTrue, e)
 2731 
 2732     case map[int8]uint32:
 2733         fastpathTV.EncMapInt8Uint32V(v, fastpathCheckNilTrue, e)
 2734     case *map[int8]uint32:
 2735         fastpathTV.EncMapInt8Uint32V(*v, fastpathCheckNilTrue, e)
 2736 
 2737     case map[int8]uint64:
 2738         fastpathTV.EncMapInt8Uint64V(v, fastpathCheckNilTrue, e)
 2739     case *map[int8]uint64:
 2740         fastpathTV.EncMapInt8Uint64V(*v, fastpathCheckNilTrue, e)
 2741 
 2742     case map[int8]uintptr:
 2743         fastpathTV.EncMapInt8UintptrV(v, fastpathCheckNilTrue, e)
 2744     case *map[int8]uintptr:
 2745         fastpathTV.EncMapInt8UintptrV(*v, fastpathCheckNilTrue, e)
 2746 
 2747     case map[int8]int:
 2748         fastpathTV.EncMapInt8IntV(v, fastpathCheckNilTrue, e)
 2749     case *map[int8]int:
 2750         fastpathTV.EncMapInt8IntV(*v, fastpathCheckNilTrue, e)
 2751 
 2752     case map[int8]int8:
 2753         fastpathTV.EncMapInt8Int8V(v, fastpathCheckNilTrue, e)
 2754     case *map[int8]int8:
 2755         fastpathTV.EncMapInt8Int8V(*v, fastpathCheckNilTrue, e)
 2756 
 2757     case map[int8]int16:
 2758         fastpathTV.EncMapInt8Int16V(v, fastpathCheckNilTrue, e)
 2759     case *map[int8]int16:
 2760         fastpathTV.EncMapInt8Int16V(*v, fastpathCheckNilTrue, e)
 2761 
 2762     case map[int8]int32:
 2763         fastpathTV.EncMapInt8Int32V(v, fastpathCheckNilTrue, e)
 2764     case *map[int8]int32:
 2765         fastpathTV.EncMapInt8Int32V(*v, fastpathCheckNilTrue, e)
 2766 
 2767     case map[int8]int64:
 2768         fastpathTV.EncMapInt8Int64V(v, fastpathCheckNilTrue, e)
 2769     case *map[int8]int64:
 2770         fastpathTV.EncMapInt8Int64V(*v, fastpathCheckNilTrue, e)
 2771 
 2772     case map[int8]float32:
 2773         fastpathTV.EncMapInt8Float32V(v, fastpathCheckNilTrue, e)
 2774     case *map[int8]float32:
 2775         fastpathTV.EncMapInt8Float32V(*v, fastpathCheckNilTrue, e)
 2776 
 2777     case map[int8]float64:
 2778         fastpathTV.EncMapInt8Float64V(v, fastpathCheckNilTrue, e)
 2779     case *map[int8]float64:
 2780         fastpathTV.EncMapInt8Float64V(*v, fastpathCheckNilTrue, e)
 2781 
 2782     case map[int8]bool:
 2783         fastpathTV.EncMapInt8BoolV(v, fastpathCheckNilTrue, e)
 2784     case *map[int8]bool:
 2785         fastpathTV.EncMapInt8BoolV(*v, fastpathCheckNilTrue, e)
 2786 
 2787     case map[int16]interface{}:
 2788         fastpathTV.EncMapInt16IntfV(v, fastpathCheckNilTrue, e)
 2789     case *map[int16]interface{}:
 2790         fastpathTV.EncMapInt16IntfV(*v, fastpathCheckNilTrue, e)
 2791 
 2792     case map[int16]string:
 2793         fastpathTV.EncMapInt16StringV(v, fastpathCheckNilTrue, e)
 2794     case *map[int16]string:
 2795         fastpathTV.EncMapInt16StringV(*v, fastpathCheckNilTrue, e)
 2796 
 2797     case map[int16]uint:
 2798         fastpathTV.EncMapInt16UintV(v, fastpathCheckNilTrue, e)
 2799     case *map[int16]uint:
 2800         fastpathTV.EncMapInt16UintV(*v, fastpathCheckNilTrue, e)
 2801 
 2802     case map[int16]uint8:
 2803         fastpathTV.EncMapInt16Uint8V(v, fastpathCheckNilTrue, e)
 2804     case *map[int16]uint8:
 2805         fastpathTV.EncMapInt16Uint8V(*v, fastpathCheckNilTrue, e)
 2806 
 2807     case map[int16]uint16:
 2808         fastpathTV.EncMapInt16Uint16V(v, fastpathCheckNilTrue, e)
 2809     case *map[int16]uint16:
 2810         fastpathTV.EncMapInt16Uint16V(*v, fastpathCheckNilTrue, e)
 2811 
 2812     case map[int16]uint32:
 2813         fastpathTV.EncMapInt16Uint32V(v, fastpathCheckNilTrue, e)
 2814     case *map[int16]uint32:
 2815         fastpathTV.EncMapInt16Uint32V(*v, fastpathCheckNilTrue, e)
 2816 
 2817     case map[int16]uint64:
 2818         fastpathTV.EncMapInt16Uint64V(v, fastpathCheckNilTrue, e)
 2819     case *map[int16]uint64:
 2820         fastpathTV.EncMapInt16Uint64V(*v, fastpathCheckNilTrue, e)
 2821 
 2822     case map[int16]uintptr:
 2823         fastpathTV.EncMapInt16UintptrV(v, fastpathCheckNilTrue, e)
 2824     case *map[int16]uintptr:
 2825         fastpathTV.EncMapInt16UintptrV(*v, fastpathCheckNilTrue, e)
 2826 
 2827     case map[int16]int:
 2828         fastpathTV.EncMapInt16IntV(v, fastpathCheckNilTrue, e)
 2829     case *map[int16]int:
 2830         fastpathTV.EncMapInt16IntV(*v, fastpathCheckNilTrue, e)
 2831 
 2832     case map[int16]int8:
 2833         fastpathTV.EncMapInt16Int8V(v, fastpathCheckNilTrue, e)
 2834     case *map[int16]int8:
 2835         fastpathTV.EncMapInt16Int8V(*v, fastpathCheckNilTrue, e)
 2836 
 2837     case map[int16]int16:
 2838         fastpathTV.EncMapInt16Int16V(v, fastpathCheckNilTrue, e)
 2839     case *map[int16]int16:
 2840         fastpathTV.EncMapInt16Int16V(*v, fastpathCheckNilTrue, e)
 2841 
 2842     case map[int16]int32:
 2843         fastpathTV.EncMapInt16Int32V(v, fastpathCheckNilTrue, e)
 2844     case *map[int16]int32:
 2845         fastpathTV.EncMapInt16Int32V(*v, fastpathCheckNilTrue, e)
 2846 
 2847     case map[int16]int64:
 2848         fastpathTV.EncMapInt16Int64V(v, fastpathCheckNilTrue, e)
 2849     case *map[int16]int64:
 2850         fastpathTV.EncMapInt16Int64V(*v, fastpathCheckNilTrue, e)
 2851 
 2852     case map[int16]float32:
 2853         fastpathTV.EncMapInt16Float32V(v, fastpathCheckNilTrue, e)
 2854     case *map[int16]float32:
 2855         fastpathTV.EncMapInt16Float32V(*v, fastpathCheckNilTrue, e)
 2856 
 2857     case map[int16]float64:
 2858         fastpathTV.EncMapInt16Float64V(v, fastpathCheckNilTrue, e)
 2859     case *map[int16]float64:
 2860         fastpathTV.EncMapInt16Float64V(*v, fastpathCheckNilTrue, e)
 2861 
 2862     case map[int16]bool:
 2863         fastpathTV.EncMapInt16BoolV(v, fastpathCheckNilTrue, e)
 2864     case *map[int16]bool:
 2865         fastpathTV.EncMapInt16BoolV(*v, fastpathCheckNilTrue, e)
 2866 
 2867     case map[int32]interface{}:
 2868         fastpathTV.EncMapInt32IntfV(v, fastpathCheckNilTrue, e)
 2869     case *map[int32]interface{}:
 2870         fastpathTV.EncMapInt32IntfV(*v, fastpathCheckNilTrue, e)
 2871 
 2872     case map[int32]string:
 2873         fastpathTV.EncMapInt32StringV(v, fastpathCheckNilTrue, e)
 2874     case *map[int32]string:
 2875         fastpathTV.EncMapInt32StringV(*v, fastpathCheckNilTrue, e)
 2876 
 2877     case map[int32]uint:
 2878         fastpathTV.EncMapInt32UintV(v, fastpathCheckNilTrue, e)
 2879     case *map[int32]uint:
 2880         fastpathTV.EncMapInt32UintV(*v, fastpathCheckNilTrue, e)
 2881 
 2882     case map[int32]uint8:
 2883         fastpathTV.EncMapInt32Uint8V(v, fastpathCheckNilTrue, e)
 2884     case *map[int32]uint8:
 2885         fastpathTV.EncMapInt32Uint8V(*v, fastpathCheckNilTrue, e)
 2886 
 2887     case map[int32]uint16:
 2888         fastpathTV.EncMapInt32Uint16V(v, fastpathCheckNilTrue, e)
 2889     case *map[int32]uint16:
 2890         fastpathTV.EncMapInt32Uint16V(*v, fastpathCheckNilTrue, e)
 2891 
 2892     case map[int32]uint32:
 2893         fastpathTV.EncMapInt32Uint32V(v, fastpathCheckNilTrue, e)
 2894     case *map[int32]uint32:
 2895         fastpathTV.EncMapInt32Uint32V(*v, fastpathCheckNilTrue, e)
 2896 
 2897     case map[int32]uint64:
 2898         fastpathTV.EncMapInt32Uint64V(v, fastpathCheckNilTrue, e)
 2899     case *map[int32]uint64:
 2900         fastpathTV.EncMapInt32Uint64V(*v, fastpathCheckNilTrue, e)
 2901 
 2902     case map[int32]uintptr:
 2903         fastpathTV.EncMapInt32UintptrV(v, fastpathCheckNilTrue, e)
 2904     case *map[int32]uintptr:
 2905         fastpathTV.EncMapInt32UintptrV(*v, fastpathCheckNilTrue, e)
 2906 
 2907     case map[int32]int:
 2908         fastpathTV.EncMapInt32IntV(v, fastpathCheckNilTrue, e)
 2909     case *map[int32]int:
 2910         fastpathTV.EncMapInt32IntV(*v, fastpathCheckNilTrue, e)
 2911 
 2912     case map[int32]int8:
 2913         fastpathTV.EncMapInt32Int8V(v, fastpathCheckNilTrue, e)
 2914     case *map[int32]int8:
 2915         fastpathTV.EncMapInt32Int8V(*v, fastpathCheckNilTrue, e)
 2916 
 2917     case map[int32]int16:
 2918         fastpathTV.EncMapInt32Int16V(v, fastpathCheckNilTrue, e)
 2919     case *map[int32]int16:
 2920         fastpathTV.EncMapInt32Int16V(*v, fastpathCheckNilTrue, e)
 2921 
 2922     case map[int32]int32:
 2923         fastpathTV.EncMapInt32Int32V(v, fastpathCheckNilTrue, e)
 2924     case *map[int32]int32:
 2925         fastpathTV.EncMapInt32Int32V(*v, fastpathCheckNilTrue, e)
 2926 
 2927     case map[int32]int64:
 2928         fastpathTV.EncMapInt32Int64V(v, fastpathCheckNilTrue, e)
 2929     case *map[int32]int64:
 2930         fastpathTV.EncMapInt32Int64V(*v, fastpathCheckNilTrue, e)
 2931 
 2932     case map[int32]float32:
 2933         fastpathTV.EncMapInt32Float32V(v, fastpathCheckNilTrue, e)
 2934     case *map[int32]float32:
 2935         fastpathTV.EncMapInt32Float32V(*v, fastpathCheckNilTrue, e)
 2936 
 2937     case map[int32]float64:
 2938         fastpathTV.EncMapInt32Float64V(v, fastpathCheckNilTrue, e)
 2939     case *map[int32]float64:
 2940         fastpathTV.EncMapInt32Float64V(*v, fastpathCheckNilTrue, e)
 2941 
 2942     case map[int32]bool:
 2943         fastpathTV.EncMapInt32BoolV(v, fastpathCheckNilTrue, e)
 2944     case *map[int32]bool:
 2945         fastpathTV.EncMapInt32BoolV(*v, fastpathCheckNilTrue, e)
 2946 
 2947     case map[int64]interface{}:
 2948         fastpathTV.EncMapInt64IntfV(v, fastpathCheckNilTrue, e)
 2949     case *map[int64]interface{}:
 2950         fastpathTV.EncMapInt64IntfV(*v, fastpathCheckNilTrue, e)
 2951 
 2952     case map[int64]string:
 2953         fastpathTV.EncMapInt64StringV(v, fastpathCheckNilTrue, e)
 2954     case *map[int64]string:
 2955         fastpathTV.EncMapInt64StringV(*v, fastpathCheckNilTrue, e)
 2956 
 2957     case map[int64]uint:
 2958         fastpathTV.EncMapInt64UintV(v, fastpathCheckNilTrue, e)
 2959     case *map[int64]uint:
 2960         fastpathTV.EncMapInt64UintV(*v, fastpathCheckNilTrue, e)
 2961 
 2962     case map[int64]uint8:
 2963         fastpathTV.EncMapInt64Uint8V(v, fastpathCheckNilTrue, e)
 2964     case *map[int64]uint8:
 2965         fastpathTV.EncMapInt64Uint8V(*v, fastpathCheckNilTrue, e)
 2966 
 2967     case map[int64]uint16:
 2968         fastpathTV.EncMapInt64Uint16V(v, fastpathCheckNilTrue, e)
 2969     case *map[int64]uint16:
 2970         fastpathTV.EncMapInt64Uint16V(*v, fastpathCheckNilTrue, e)
 2971 
 2972     case map[int64]uint32:
 2973         fastpathTV.EncMapInt64Uint32V(v, fastpathCheckNilTrue, e)
 2974     case *map[int64]uint32:
 2975         fastpathTV.EncMapInt64Uint32V(*v, fastpathCheckNilTrue, e)
 2976 
 2977     case map[int64]uint64:
 2978         fastpathTV.EncMapInt64Uint64V(v, fastpathCheckNilTrue, e)
 2979     case *map[int64]uint64:
 2980         fastpathTV.EncMapInt64Uint64V(*v, fastpathCheckNilTrue, e)
 2981 
 2982     case map[int64]uintptr:
 2983         fastpathTV.EncMapInt64UintptrV(v, fastpathCheckNilTrue, e)
 2984     case *map[int64]uintptr:
 2985         fastpathTV.EncMapInt64UintptrV(*v, fastpathCheckNilTrue, e)
 2986 
 2987     case map[int64]int:
 2988         fastpathTV.EncMapInt64IntV(v, fastpathCheckNilTrue, e)
 2989     case *map[int64]int:
 2990         fastpathTV.EncMapInt64IntV(*v, fastpathCheckNilTrue, e)
 2991 
 2992     case map[int64]int8:
 2993         fastpathTV.EncMapInt64Int8V(v, fastpathCheckNilTrue, e)
 2994     case *map[int64]int8:
 2995         fastpathTV.EncMapInt64Int8V(*v, fastpathCheckNilTrue, e)
 2996 
 2997     case map[int64]int16:
 2998         fastpathTV.EncMapInt64Int16V(v, fastpathCheckNilTrue, e)
 2999     case *map[int64]int16:
 3000         fastpathTV.EncMapInt64Int16V(*v, fastpathCheckNilTrue, e)
 3001 
 3002     case map[int64]int32:
 3003         fastpathTV.EncMapInt64Int32V(v, fastpathCheckNilTrue, e)
 3004     case *map[int64]int32:
 3005         fastpathTV.EncMapInt64Int32V(*v, fastpathCheckNilTrue, e)
 3006 
 3007     case map[int64]int64:
 3008         fastpathTV.EncMapInt64Int64V(v, fastpathCheckNilTrue, e)
 3009     case *map[int64]int64:
 3010         fastpathTV.EncMapInt64Int64V(*v, fastpathCheckNilTrue, e)
 3011 
 3012     case map[int64]float32:
 3013         fastpathTV.EncMapInt64Float32V(v, fastpathCheckNilTrue, e)
 3014     case *map[int64]float32:
 3015         fastpathTV.EncMapInt64Float32V(*v, fastpathCheckNilTrue, e)
 3016 
 3017     case map[int64]float64:
 3018         fastpathTV.EncMapInt64Float64V(v, fastpathCheckNilTrue, e)
 3019     case *map[int64]float64:
 3020         fastpathTV.EncMapInt64Float64V(*v, fastpathCheckNilTrue, e)
 3021 
 3022     case map[int64]bool:
 3023         fastpathTV.EncMapInt64BoolV(v, fastpathCheckNilTrue, e)
 3024     case *map[int64]bool:
 3025         fastpathTV.EncMapInt64BoolV(*v, fastpathCheckNilTrue, e)
 3026 
 3027     case map[bool]interface{}:
 3028         fastpathTV.EncMapBoolIntfV(v, fastpathCheckNilTrue, e)
 3029     case *map[bool]interface{}:
 3030         fastpathTV.EncMapBoolIntfV(*v, fastpathCheckNilTrue, e)
 3031 
 3032     case map[bool]string:
 3033         fastpathTV.EncMapBoolStringV(v, fastpathCheckNilTrue, e)
 3034     case *map[bool]string:
 3035         fastpathTV.EncMapBoolStringV(*v, fastpathCheckNilTrue, e)
 3036 
 3037     case map[bool]uint:
 3038         fastpathTV.EncMapBoolUintV(v, fastpathCheckNilTrue, e)
 3039     case *map[bool]uint:
 3040         fastpathTV.EncMapBoolUintV(*v, fastpathCheckNilTrue, e)
 3041 
 3042     case map[bool]uint8:
 3043         fastpathTV.EncMapBoolUint8V(v, fastpathCheckNilTrue, e)
 3044     case *map[bool]uint8:
 3045         fastpathTV.EncMapBoolUint8V(*v, fastpathCheckNilTrue, e)
 3046 
 3047     case map[bool]uint16:
 3048         fastpathTV.EncMapBoolUint16V(v, fastpathCheckNilTrue, e)
 3049     case *map[bool]uint16:
 3050         fastpathTV.EncMapBoolUint16V(*v, fastpathCheckNilTrue, e)
 3051 
 3052     case map[bool]uint32:
 3053         fastpathTV.EncMapBoolUint32V(v, fastpathCheckNilTrue, e)
 3054     case *map[bool]uint32:
 3055         fastpathTV.EncMapBoolUint32V(*v, fastpathCheckNilTrue, e)
 3056 
 3057     case map[bool]uint64:
 3058         fastpathTV.EncMapBoolUint64V(v, fastpathCheckNilTrue, e)
 3059     case *map[bool]uint64:
 3060         fastpathTV.EncMapBoolUint64V(*v, fastpathCheckNilTrue, e)
 3061 
 3062     case map[bool]uintptr:
 3063         fastpathTV.EncMapBoolUintptrV(v, fastpathCheckNilTrue, e)
 3064     case *map[bool]uintptr:
 3065         fastpathTV.EncMapBoolUintptrV(*v, fastpathCheckNilTrue, e)
 3066 
 3067     case map[bool]int:
 3068         fastpathTV.EncMapBoolIntV(v, fastpathCheckNilTrue, e)
 3069     case *map[bool]int:
 3070         fastpathTV.EncMapBoolIntV(*v, fastpathCheckNilTrue, e)
 3071 
 3072     case map[bool]int8:
 3073         fastpathTV.EncMapBoolInt8V(v, fastpathCheckNilTrue, e)
 3074     case *map[bool]int8:
 3075         fastpathTV.EncMapBoolInt8V(*v, fastpathCheckNilTrue, e)
 3076 
 3077     case map[bool]int16:
 3078         fastpathTV.EncMapBoolInt16V(v, fastpathCheckNilTrue, e)
 3079     case *map[bool]int16:
 3080         fastpathTV.EncMapBoolInt16V(*v, fastpathCheckNilTrue, e)
 3081 
 3082     case map[bool]int32:
 3083         fastpathTV.EncMapBoolInt32V(v, fastpathCheckNilTrue, e)
 3084     case *map[bool]int32:
 3085         fastpathTV.EncMapBoolInt32V(*v, fastpathCheckNilTrue, e)
 3086 
 3087     case map[bool]int64:
 3088         fastpathTV.EncMapBoolInt64V(v, fastpathCheckNilTrue, e)
 3089     case *map[bool]int64:
 3090         fastpathTV.EncMapBoolInt64V(*v, fastpathCheckNilTrue, e)
 3091 
 3092     case map[bool]float32:
 3093         fastpathTV.EncMapBoolFloat32V(v, fastpathCheckNilTrue, e)
 3094     case *map[bool]float32:
 3095         fastpathTV.EncMapBoolFloat32V(*v, fastpathCheckNilTrue, e)
 3096 
 3097     case map[bool]float64:
 3098         fastpathTV.EncMapBoolFloat64V(v, fastpathCheckNilTrue, e)
 3099     case *map[bool]float64:
 3100         fastpathTV.EncMapBoolFloat64V(*v, fastpathCheckNilTrue, e)
 3101 
 3102     case map[bool]bool:
 3103         fastpathTV.EncMapBoolBoolV(v, fastpathCheckNilTrue, e)
 3104     case *map[bool]bool:
 3105         fastpathTV.EncMapBoolBoolV(*v, fastpathCheckNilTrue, e)
 3106 
 3107     default:
 3108         _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
 3109         return false
 3110     }
 3111     return true
 3112 }
 3113 
 3114 // -- -- fast path functions
 3115 
 3116 func (f *encFnInfo) fastpathEncSliceIntfR(rv reflect.Value) {
 3117     if f.ti.mbs {
 3118         fastpathTV.EncAsMapSliceIntfV(rv.Interface().([]interface{}), fastpathCheckNilFalse, f.e)
 3119     } else {
 3120         fastpathTV.EncSliceIntfV(rv.Interface().([]interface{}), fastpathCheckNilFalse, f.e)
 3121     }
 3122 }
 3123 func (_ fastpathT) EncSliceIntfV(v []interface{}, checkNil bool, e *Encoder) {
 3124     ee := e.e
 3125     cr := e.cr
 3126     if checkNil && v == nil {
 3127         ee.EncodeNil()
 3128         return
 3129     }
 3130     ee.EncodeArrayStart(len(v))
 3131     for _, v2 := range v {
 3132         if cr != nil {
 3133             cr.sendContainerState(containerArrayElem)
 3134         }
 3135         e.encode(v2)
 3136     }
 3137     if cr != nil {
 3138         cr.sendContainerState(containerArrayEnd)
 3139     }
 3140 }
 3141 
 3142 func (_ fastpathT) EncAsMapSliceIntfV(v []interface{}, checkNil bool, e *Encoder) {
 3143     ee := e.e
 3144     cr := e.cr
 3145     if checkNil && v == nil {
 3146         ee.EncodeNil()
 3147         return
 3148     }
 3149     if len(v)%2 == 1 {
 3150         e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 3151         return
 3152     }
 3153     ee.EncodeMapStart(len(v) / 2)
 3154     for j, v2 := range v {
 3155         if cr != nil {
 3156             if j%2 == 0 {
 3157                 cr.sendContainerState(containerMapKey)
 3158             } else {
 3159                 cr.sendContainerState(containerMapValue)
 3160             }
 3161         }
 3162         e.encode(v2)
 3163     }
 3164     if cr != nil {
 3165         cr.sendContainerState(containerMapEnd)
 3166     }
 3167 }
 3168 
 3169 func (f *encFnInfo) fastpathEncSliceStringR(rv reflect.Value) {
 3170     if f.ti.mbs {
 3171         fastpathTV.EncAsMapSliceStringV(rv.Interface().([]string), fastpathCheckNilFalse, f.e)
 3172     } else {
 3173         fastpathTV.EncSliceStringV(rv.Interface().([]string), fastpathCheckNilFalse, f.e)
 3174     }
 3175 }
 3176 func (_ fastpathT) EncSliceStringV(v []string, checkNil bool, e *Encoder) {
 3177     ee := e.e
 3178     cr := e.cr
 3179     if checkNil && v == nil {
 3180         ee.EncodeNil()
 3181         return
 3182     }
 3183     ee.EncodeArrayStart(len(v))
 3184     for _, v2 := range v {
 3185         if cr != nil {
 3186             cr.sendContainerState(containerArrayElem)
 3187         }
 3188         ee.EncodeString(c_UTF8, v2)
 3189     }
 3190     if cr != nil {
 3191         cr.sendContainerState(containerArrayEnd)
 3192     }
 3193 }
 3194 
 3195 func (_ fastpathT) EncAsMapSliceStringV(v []string, checkNil bool, e *Encoder) {
 3196     ee := e.e
 3197     cr := e.cr
 3198     if checkNil && v == nil {
 3199         ee.EncodeNil()
 3200         return
 3201     }
 3202     if len(v)%2 == 1 {
 3203         e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 3204         return
 3205     }
 3206     ee.EncodeMapStart(len(v) / 2)
 3207     for j, v2 := range v {
 3208         if cr != nil {
 3209             if j%2 == 0 {
 3210                 cr.sendContainerState(containerMapKey)
 3211             } else {
 3212                 cr.sendContainerState(containerMapValue)
 3213             }
 3214         }
 3215         ee.EncodeString(c_UTF8, v2)
 3216     }
 3217     if cr != nil {
 3218         cr.sendContainerState(containerMapEnd)
 3219     }
 3220 }
 3221 
 3222 func (f *encFnInfo) fastpathEncSliceFloat32R(rv reflect.Value) {
 3223     if f.ti.mbs {
 3224         fastpathTV.EncAsMapSliceFloat32V(rv.Interface().([]float32), fastpathCheckNilFalse, f.e)
 3225     } else {
 3226         fastpathTV.EncSliceFloat32V(rv.Interface().([]float32), fastpathCheckNilFalse, f.e)
 3227     }
 3228 }
 3229 func (_ fastpathT) EncSliceFloat32V(v []float32, checkNil bool, e *Encoder) {
 3230     ee := e.e
 3231     cr := e.cr
 3232     if checkNil && v == nil {
 3233         ee.EncodeNil()
 3234         return
 3235     }
 3236     ee.EncodeArrayStart(len(v))
 3237     for _, v2 := range v {
 3238         if cr != nil {
 3239             cr.sendContainerState(containerArrayElem)
 3240         }
 3241         ee.EncodeFloat32(v2)
 3242     }
 3243     if cr != nil {
 3244         cr.sendContainerState(containerArrayEnd)
 3245     }
 3246 }
 3247 
 3248 func (_ fastpathT) EncAsMapSliceFloat32V(v []float32, checkNil bool, e *Encoder) {
 3249     ee := e.e
 3250     cr := e.cr
 3251     if checkNil && v == nil {
 3252         ee.EncodeNil()
 3253         return
 3254     }
 3255     if len(v)%2 == 1 {
 3256         e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 3257         return
 3258     }
 3259     ee.EncodeMapStart(len(v) / 2)
 3260     for j, v2 := range v {
 3261         if cr != nil {
 3262             if j%2 == 0 {
 3263                 cr.sendContainerState(containerMapKey)
 3264             } else {
 3265                 cr.sendContainerState(containerMapValue)
 3266             }
 3267         }
 3268         ee.EncodeFloat32(v2)
 3269     }
 3270     if cr != nil {
 3271         cr.sendContainerState(containerMapEnd)
 3272     }
 3273 }
 3274 
 3275 func (f *encFnInfo) fastpathEncSliceFloat64R(rv reflect.Value) {
 3276     if f.ti.mbs {
 3277         fastpathTV.EncAsMapSliceFloat64V(rv.Interface().([]float64), fastpathCheckNilFalse, f.e)
 3278     } else {
 3279         fastpathTV.EncSliceFloat64V(rv.Interface().([]float64), fastpathCheckNilFalse, f.e)
 3280     }
 3281 }
 3282 func (_ fastpathT) EncSliceFloat64V(v []float64, checkNil bool, e *Encoder) {
 3283     ee := e.e
 3284     cr := e.cr
 3285     if checkNil && v == nil {
 3286         ee.EncodeNil()
 3287         return
 3288     }
 3289     ee.EncodeArrayStart(len(v))
 3290     for _, v2 := range v {
 3291         if cr != nil {
 3292             cr.sendContainerState(containerArrayElem)
 3293         }
 3294         ee.EncodeFloat64(v2)
 3295     }
 3296     if cr != nil {
 3297         cr.sendContainerState(containerArrayEnd)
 3298     }
 3299 }
 3300 
 3301 func (_ fastpathT) EncAsMapSliceFloat64V(v []float64, checkNil bool, e *Encoder) {
 3302     ee := e.e
 3303     cr := e.cr
 3304     if checkNil && v == nil {
 3305         ee.EncodeNil()
 3306         return
 3307     }
 3308     if len(v)%2 == 1 {
 3309         e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 3310         return
 3311     }
 3312     ee.EncodeMapStart(len(v) / 2)
 3313     for j, v2 := range v {
 3314         if cr != nil {
 3315             if j%2 == 0 {
 3316                 cr.sendContainerState(containerMapKey)
 3317             } else {
 3318                 cr.sendContainerState(containerMapValue)
 3319             }
 3320         }
 3321         ee.EncodeFloat64(v2)
 3322     }
 3323     if cr != nil {
 3324         cr.sendContainerState(containerMapEnd)
 3325     }
 3326 }
 3327 
 3328 func (f *encFnInfo) fastpathEncSliceUintR(rv reflect.Value) {
 3329     if f.ti.mbs {
 3330         fastpathTV.EncAsMapSliceUintV(rv.Interface().([]uint), fastpathCheckNilFalse, f.e)
 3331     } else {
 3332         fastpathTV.EncSliceUintV(rv.Interface().([]uint), fastpathCheckNilFalse, f.e)
 3333     }
 3334 }
 3335 func (_ fastpathT) EncSliceUintV(v []uint, checkNil bool, e *Encoder) {
 3336     ee := e.e
 3337     cr := e.cr
 3338     if checkNil && v == nil {
 3339         ee.EncodeNil()
 3340         return
 3341     }
 3342     ee.EncodeArrayStart(len(v))
 3343     for _, v2 := range v {
 3344         if cr != nil {
 3345             cr.sendContainerState(containerArrayElem)
 3346         }
 3347         ee.EncodeUint(uint64(v2))
 3348     }
 3349     if cr != nil {
 3350         cr.sendContainerState(containerArrayEnd)
 3351     }
 3352 }
 3353 
 3354 func (_ fastpathT) EncAsMapSliceUintV(v []uint, checkNil bool, e *Encoder) {
 3355     ee := e.e
 3356     cr := e.cr
 3357     if checkNil && v == nil {
 3358         ee.EncodeNil()
 3359         return
 3360     }
 3361     if len(v)%2 == 1 {
 3362         e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 3363         return
 3364     }
 3365     ee.EncodeMapStart(len(v) / 2)
 3366     for j, v2 := range v {
 3367         if cr != nil {
 3368             if j%2 == 0 {
 3369                 cr.sendContainerState(containerMapKey)
 3370             } else {
 3371                 cr.sendContainerState(containerMapValue)
 3372             }
 3373         }
 3374         ee.EncodeUint(uint64(v2))
 3375     }
 3376     if cr != nil {
 3377         cr.sendContainerState(containerMapEnd)
 3378     }
 3379 }
 3380 
 3381 func (f *encFnInfo) fastpathEncSliceUint16R(rv reflect.Value) {
 3382     if f.ti.mbs {
 3383         fastpathTV.EncAsMapSliceUint16V(rv.Interface().([]uint16), fastpathCheckNilFalse, f.e)
 3384     } else {
 3385         fastpathTV.EncSliceUint16V(rv.Interface().([]uint16), fastpathCheckNilFalse, f.e)
 3386     }
 3387 }
 3388 func (_ fastpathT) EncSliceUint16V(v []uint16, checkNil bool, e *Encoder) {
 3389     ee := e.e
 3390     cr := e.cr
 3391     if checkNil && v == nil {
 3392         ee.EncodeNil()
 3393         return
 3394     }
 3395     ee.EncodeArrayStart(len(v))
 3396     for _, v2 := range v {
 3397         if cr != nil {
 3398             cr.sendContainerState(containerArrayElem)
 3399         }
 3400         ee.EncodeUint(uint64(v2))
 3401     }
 3402     if cr != nil {
 3403         cr.sendContainerState(containerArrayEnd)
 3404     }
 3405 }
 3406 
 3407 func (_ fastpathT) EncAsMapSliceUint16V(v []uint16, checkNil bool, e *Encoder) {
 3408     ee := e.e
 3409     cr := e.cr
 3410     if checkNil && v == nil {
 3411         ee.EncodeNil()
 3412         return
 3413     }
 3414     if len(v)%2 == 1 {
 3415         e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 3416         return
 3417     }
 3418     ee.EncodeMapStart(len(v) / 2)
 3419     for j, v2 := range v {
 3420         if cr != nil {
 3421             if j%2 == 0 {
 3422                 cr.sendContainerState(containerMapKey)
 3423             } else {
 3424                 cr.sendContainerState(containerMapValue)
 3425             }
 3426         }
 3427         ee.EncodeUint(uint64(v2))
 3428     }
 3429     if cr != nil {
 3430         cr.sendContainerState(containerMapEnd)
 3431     }
 3432 }
 3433 
 3434 func (f *encFnInfo) fastpathEncSliceUint32R(rv reflect.Value) {
 3435     if f.ti.mbs {
 3436         fastpathTV.EncAsMapSliceUint32V(rv.Interface().([]uint32), fastpathCheckNilFalse, f.e)
 3437     } else {
 3438         fastpathTV.EncSliceUint32V(rv.Interface().([]uint32), fastpathCheckNilFalse, f.e)
 3439     }
 3440 }
 3441 func (_ fastpathT) EncSliceUint32V(v []uint32, checkNil bool, e *Encoder) {
 3442     ee := e.e
 3443     cr := e.cr
 3444     if checkNil && v == nil {
 3445         ee.EncodeNil()
 3446         return
 3447     }
 3448     ee.EncodeArrayStart(len(v))
 3449     for _, v2 := range v {
 3450         if cr != nil {
 3451             cr.sendContainerState(containerArrayElem)
 3452         }
 3453         ee.EncodeUint(uint64(v2))
 3454     }
 3455     if cr != nil {
 3456         cr.sendContainerState(containerArrayEnd)
 3457     }
 3458 }
 3459 
 3460 func (_ fastpathT) EncAsMapSliceUint32V(v []uint32, checkNil bool, e *Encoder) {
 3461     ee := e.e
 3462     cr := e.cr
 3463     if checkNil && v == nil {
 3464         ee.EncodeNil()
 3465         return
 3466     }
 3467     if len(v)%2 == 1 {
 3468         e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 3469         return
 3470     }
 3471     ee.EncodeMapStart(len(v) / 2)
 3472     for j, v2 := range v {
 3473         if cr != nil {
 3474             if j%2 == 0 {
 3475                 cr.sendContainerState(containerMapKey)
 3476             } else {
 3477                 cr.sendContainerState(containerMapValue)
 3478             }
 3479         }
 3480         ee.EncodeUint(uint64(v2))
 3481     }
 3482     if cr != nil {
 3483         cr.sendContainerState(containerMapEnd)
 3484     }
 3485 }
 3486 
 3487 func (f *encFnInfo) fastpathEncSliceUint64R(rv reflect.Value) {
 3488     if f.ti.mbs {
 3489         fastpathTV.EncAsMapSliceUint64V(rv.Interface().([]uint64), fastpathCheckNilFalse, f.e)
 3490     } else {
 3491         fastpathTV.EncSliceUint64V(rv.Interface().([]uint64), fastpathCheckNilFalse, f.e)
 3492     }
 3493 }
 3494 func (_ fastpathT) EncSliceUint64V(v []uint64, checkNil bool, e *Encoder) {
 3495     ee := e.e
 3496     cr := e.cr
 3497     if checkNil && v == nil {
 3498         ee.EncodeNil()
 3499         return
 3500     }
 3501     ee.EncodeArrayStart(len(v))
 3502     for _, v2 := range v {
 3503         if cr != nil {
 3504             cr.sendContainerState(containerArrayElem)
 3505         }
 3506         ee.EncodeUint(uint64(v2))
 3507     }
 3508     if cr != nil {
 3509         cr.sendContainerState(containerArrayEnd)
 3510     }
 3511 }
 3512 
 3513 func (_ fastpathT) EncAsMapSliceUint64V(v []uint64, checkNil bool, e *Encoder) {
 3514     ee := e.e
 3515     cr := e.cr
 3516     if checkNil && v == nil {
 3517         ee.EncodeNil()
 3518         return
 3519     }
 3520     if len(v)%2 == 1 {
 3521         e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 3522         return
 3523     }
 3524     ee.EncodeMapStart(len(v) / 2)
 3525     for j, v2 := range v {
 3526         if cr != nil {
 3527             if j%2 == 0 {
 3528                 cr.sendContainerState(containerMapKey)
 3529             } else {
 3530                 cr.sendContainerState(containerMapValue)
 3531             }
 3532         }
 3533         ee.EncodeUint(uint64(v2))
 3534     }
 3535     if cr != nil {
 3536         cr.sendContainerState(containerMapEnd)
 3537     }
 3538 }
 3539 
 3540 func (f *encFnInfo) fastpathEncSliceUintptrR(rv reflect.Value) {
 3541     if f.ti.mbs {
 3542         fastpathTV.EncAsMapSliceUintptrV(rv.Interface().([]uintptr), fastpathCheckNilFalse, f.e)
 3543     } else {
 3544         fastpathTV.EncSliceUintptrV(rv.Interface().([]uintptr), fastpathCheckNilFalse, f.e)
 3545     }
 3546 }
 3547 func (_ fastpathT) EncSliceUintptrV(v []uintptr, checkNil bool, e *Encoder) {
 3548     ee := e.e
 3549     cr := e.cr
 3550     if checkNil && v == nil {
 3551         ee.EncodeNil()
 3552         return
 3553     }
 3554     ee.EncodeArrayStart(len(v))
 3555     for _, v2 := range v {
 3556         if cr != nil {
 3557             cr.sendContainerState(containerArrayElem)
 3558         }
 3559         e.encode(v2)
 3560     }
 3561     if cr != nil {
 3562         cr.sendContainerState(containerArrayEnd)
 3563     }
 3564 }
 3565 
 3566 func (_ fastpathT) EncAsMapSliceUintptrV(v []uintptr, checkNil bool, e *Encoder) {
 3567     ee := e.e
 3568     cr := e.cr
 3569     if checkNil && v == nil {
 3570         ee.EncodeNil()
 3571         return
 3572     }
 3573     if len(v)%2 == 1 {
 3574         e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 3575         return
 3576     }
 3577     ee.EncodeMapStart(len(v) / 2)
 3578     for j, v2 := range v {
 3579         if cr != nil {
 3580             if j%2 == 0 {
 3581                 cr.sendContainerState(containerMapKey)
 3582             } else {
 3583                 cr.sendContainerState(containerMapValue)
 3584             }
 3585         }
 3586         e.encode(v2)
 3587     }
 3588     if cr != nil {
 3589         cr.sendContainerState(containerMapEnd)
 3590     }
 3591 }
 3592 
 3593 func (f *encFnInfo) fastpathEncSliceIntR(rv reflect.Value) {
 3594     if f.ti.mbs {
 3595         fastpathTV.EncAsMapSliceIntV(rv.Interface().([]int), fastpathCheckNilFalse, f.e)
 3596     } else {
 3597         fastpathTV.EncSliceIntV(rv.Interface().([]int), fastpathCheckNilFalse, f.e)
 3598     }
 3599 }
 3600 func (_ fastpathT) EncSliceIntV(v []int, checkNil bool, e *Encoder) {
 3601     ee := e.e
 3602     cr := e.cr
 3603     if checkNil && v == nil {
 3604         ee.EncodeNil()
 3605         return
 3606     }
 3607     ee.EncodeArrayStart(len(v))
 3608     for _, v2 := range v {
 3609         if cr != nil {
 3610             cr.sendContainerState(containerArrayElem)
 3611         }
 3612         ee.EncodeInt(int64(v2))
 3613     }
 3614     if cr != nil {
 3615         cr.sendContainerState(containerArrayEnd)
 3616     }
 3617 }
 3618 
 3619 func (_ fastpathT) EncAsMapSliceIntV(v []int, checkNil bool, e *Encoder) {
 3620     ee := e.e
 3621     cr := e.cr
 3622     if checkNil && v == nil {
 3623         ee.EncodeNil()
 3624         return
 3625     }
 3626     if len(v)%2 == 1 {
 3627         e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 3628         return
 3629     }
 3630     ee.EncodeMapStart(len(v) / 2)
 3631     for j, v2 := range v {
 3632         if cr != nil {
 3633             if j%2 == 0 {
 3634                 cr.sendContainerState(containerMapKey)
 3635             } else {
 3636                 cr.sendContainerState(containerMapValue)
 3637             }
 3638         }
 3639         ee.EncodeInt(int64(v2))
 3640     }
 3641     if cr != nil {
 3642         cr.sendContainerState(containerMapEnd)
 3643     }
 3644 }
 3645 
 3646 func (f *encFnInfo) fastpathEncSliceInt8R(rv reflect.Value) {
 3647     if f.ti.mbs {
 3648         fastpathTV.EncAsMapSliceInt8V(rv.Interface().([]int8), fastpathCheckNilFalse, f.e)
 3649     } else {
 3650         fastpathTV.EncSliceInt8V(rv.Interface().([]int8), fastpathCheckNilFalse, f.e)
 3651     }
 3652 }
 3653 func (_ fastpathT) EncSliceInt8V(v []int8, checkNil bool, e *Encoder) {
 3654     ee := e.e
 3655     cr := e.cr
 3656     if checkNil && v == nil {
 3657         ee.EncodeNil()
 3658         return
 3659     }
 3660     ee.EncodeArrayStart(len(v))
 3661     for _, v2 := range v {
 3662         if cr != nil {
 3663             cr.sendContainerState(containerArrayElem)
 3664         }
 3665         ee.EncodeInt(int64(v2))
 3666     }
 3667     if cr != nil {
 3668         cr.sendContainerState(containerArrayEnd)
 3669     }
 3670 }
 3671 
 3672 func (_ fastpathT) EncAsMapSliceInt8V(v []int8, checkNil bool, e *Encoder) {
 3673     ee := e.e
 3674     cr := e.cr
 3675     if checkNil && v == nil {
 3676         ee.EncodeNil()
 3677         return
 3678     }
 3679     if len(v)%2 == 1 {
 3680         e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 3681         return
 3682     }
 3683     ee.EncodeMapStart(len(v) / 2)
 3684     for j, v2 := range v {
 3685         if cr != nil {
 3686             if j%2 == 0 {
 3687                 cr.sendContainerState(containerMapKey)
 3688             } else {
 3689                 cr.sendContainerState(containerMapValue)
 3690             }
 3691         }
 3692         ee.EncodeInt(int64(v2))
 3693     }
 3694     if cr != nil {
 3695         cr.sendContainerState(containerMapEnd)
 3696     }
 3697 }
 3698 
 3699 func (f *encFnInfo) fastpathEncSliceInt16R(rv reflect.Value) {
 3700     if f.ti.mbs {
 3701         fastpathTV.EncAsMapSliceInt16V(rv.Interface().([]int16), fastpathCheckNilFalse, f.e)
 3702     } else {
 3703         fastpathTV.EncSliceInt16V(rv.Interface().([]int16), fastpathCheckNilFalse, f.e)
 3704     }
 3705 }
 3706 func (_ fastpathT) EncSliceInt16V(v []int16, checkNil bool, e *Encoder) {
 3707     ee := e.e
 3708     cr := e.cr
 3709     if checkNil && v == nil {
 3710         ee.EncodeNil()
 3711         return
 3712     }
 3713     ee.EncodeArrayStart(len(v))
 3714     for _, v2 := range v {
 3715         if cr != nil {
 3716             cr.sendContainerState(containerArrayElem)
 3717         }
 3718         ee.EncodeInt(int64(v2))
 3719     }
 3720     if cr != nil {
 3721         cr.sendContainerState(containerArrayEnd)
 3722     }
 3723 }
 3724 
 3725 func (_ fastpathT) EncAsMapSliceInt16V(v []int16, checkNil bool, e *Encoder) {
 3726     ee := e.e
 3727     cr := e.cr
 3728     if checkNil && v == nil {
 3729         ee.EncodeNil()
 3730         return
 3731     }
 3732     if len(v)%2 == 1 {
 3733         e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 3734         return
 3735     }
 3736     ee.EncodeMapStart(len(v) / 2)
 3737     for j, v2 := range v {
 3738         if cr != nil {
 3739             if j%2 == 0 {
 3740                 cr.sendContainerState(containerMapKey)
 3741             } else {
 3742                 cr.sendContainerState(containerMapValue)
 3743             }
 3744         }
 3745         ee.EncodeInt(int64(v2))
 3746     }
 3747     if cr != nil {
 3748         cr.sendContainerState(containerMapEnd)
 3749     }
 3750 }
 3751 
 3752 func (f *encFnInfo) fastpathEncSliceInt32R(rv reflect.Value) {
 3753     if f.ti.mbs {
 3754         fastpathTV.EncAsMapSliceInt32V(rv.Interface().([]int32), fastpathCheckNilFalse, f.e)
 3755     } else {
 3756         fastpathTV.EncSliceInt32V(rv.Interface().([]int32), fastpathCheckNilFalse, f.e)
 3757     }
 3758 }
 3759 func (_ fastpathT) EncSliceInt32V(v []int32, checkNil bool, e *Encoder) {
 3760     ee := e.e
 3761     cr := e.cr
 3762     if checkNil && v == nil {
 3763         ee.EncodeNil()
 3764         return
 3765     }
 3766     ee.EncodeArrayStart(len(v))
 3767     for _, v2 := range v {
 3768         if cr != nil {
 3769             cr.sendContainerState(containerArrayElem)
 3770         }
 3771         ee.EncodeInt(int64(v2))
 3772     }
 3773     if cr != nil {
 3774         cr.sendContainerState(containerArrayEnd)
 3775     }
 3776 }
 3777 
 3778 func (_ fastpathT) EncAsMapSliceInt32V(v []int32, checkNil bool, e *Encoder) {
 3779     ee := e.e
 3780     cr := e.cr
 3781     if checkNil && v == nil {
 3782         ee.EncodeNil()
 3783         return
 3784     }
 3785     if len(v)%2 == 1 {
 3786         e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 3787         return
 3788     }
 3789     ee.EncodeMapStart(len(v) / 2)
 3790     for j, v2 := range v {
 3791         if cr != nil {
 3792             if j%2 == 0 {
 3793                 cr.sendContainerState(containerMapKey)
 3794             } else {
 3795                 cr.sendContainerState(containerMapValue)
 3796             }
 3797         }
 3798         ee.EncodeInt(int64(v2))
 3799     }
 3800     if cr != nil {
 3801         cr.sendContainerState(containerMapEnd)
 3802     }
 3803 }
 3804 
 3805 func (f *encFnInfo) fastpathEncSliceInt64R(rv reflect.Value) {
 3806     if f.ti.mbs {
 3807         fastpathTV.EncAsMapSliceInt64V(rv.Interface().([]int64), fastpathCheckNilFalse, f.e)
 3808     } else {
 3809         fastpathTV.EncSliceInt64V(rv.Interface().([]int64), fastpathCheckNilFalse, f.e)
 3810     }
 3811 }
 3812 func (_ fastpathT) EncSliceInt64V(v []int64, checkNil bool, e *Encoder) {
 3813     ee := e.e
 3814     cr := e.cr
 3815     if checkNil && v == nil {
 3816         ee.EncodeNil()
 3817         return
 3818     }
 3819     ee.EncodeArrayStart(len(v))
 3820     for _, v2 := range v {
 3821         if cr != nil {
 3822             cr.sendContainerState(containerArrayElem)
 3823         }
 3824         ee.EncodeInt(int64(v2))
 3825     }
 3826     if cr != nil {
 3827         cr.sendContainerState(containerArrayEnd)
 3828     }
 3829 }
 3830 
 3831 func (_ fastpathT) EncAsMapSliceInt64V(v []int64, checkNil bool, e *Encoder) {
 3832     ee := e.e
 3833     cr := e.cr
 3834     if checkNil && v == nil {
 3835         ee.EncodeNil()
 3836         return
 3837     }
 3838     if len(v)%2 == 1 {
 3839         e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 3840         return
 3841     }
 3842     ee.EncodeMapStart(len(v) / 2)
 3843     for j, v2 := range v {
 3844         if cr != nil {
 3845             if j%2 == 0 {
 3846                 cr.sendContainerState(containerMapKey)
 3847             } else {
 3848                 cr.sendContainerState(conta