Grand test fixup (#138)

* start fixing up tests

* fix up tests + automate with drone

* fiddle with linting

* messing about with drone.yml

* some more fiddling

* hmmm

* add cache

* add vendor directory

* verbose

* ci updates

* update some little things

* update sig

vendor/github.com/ugorji/go/codec/0_importpath.go

@@ -0,0 +1,7 @@
+// Copyright (c) 2012-2018 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+package codec // import "github.com/ugorji/go/codec"
+
+// This establishes that this package must be imported as github.com/ugorji/go/codec.
+// It makes forking easier, and plays well with pre-module releases of go.

vendor/github.com/ugorji/go/codec/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2012-2020 Ugorji Nwoke.
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/ugorji/go/codec/README.md

@@ -0,0 +1,283 @@
+# Package Documentation for github.com/ugorji/go/codec
+
+Package codec provides a High Performance, Feature-Rich Idiomatic Go 1.4+
+codec/encoding library for binc, msgpack, cbor, json.
+
+Supported Serialization formats are:
+
+  - msgpack: https://github.com/msgpack/msgpack
+  - binc:    http://github.com/ugorji/binc
+  - cbor:    http://cbor.io http://tools.ietf.org/html/rfc7049
+  - json:    http://json.org http://tools.ietf.org/html/rfc7159
+  - simple:
+
+This package will carefully use 'package unsafe' for performance reasons in
+specific places. You can build without unsafe use by passing the safe or
+appengine tag i.e. 'go install -tags=codec.safe ...'.
+
+This library works with both the standard `gc` and the `gccgo` compilers.
+
+For detailed usage information, read the primer at
+http://ugorji.net/blog/go-codec-primer .
+
+The idiomatic Go support is as seen in other encoding packages in the
+standard library (ie json, xml, gob, etc).
+
+Rich Feature Set includes:
+
+  - Simple but extremely powerful and feature-rich API
+  - Support for go 1.4 and above, while selectively using newer APIs for later releases
+  - Excellent code coverage ( > 90% )
+  - Very High Performance.
+    Our extensive benchmarks show us outperforming Gob, Json, Bson, etc by 2-4X.
+  - Careful selected use of 'unsafe' for targeted performance gains.
+  - 100% safe mode supported, where 'unsafe' is not used at all.
+  - Lock-free (sans mutex) concurrency for scaling to 100's of cores
+  - In-place updates during decode, with option to zero value in maps and slices prior to decode
+  - Coerce types where appropriate
+    e.g. decode an int in the stream into a float, decode numbers from formatted strings, etc
+  - Corner Cases:
+    Overflows, nil maps/slices, nil values in streams are handled correctly
+  - Standard field renaming via tags
+  - Support for omitting empty fields during an encoding
+  - Encoding from any value and decoding into pointer to any value
+    (struct, slice, map, primitives, pointers, interface{}, etc)
+  - Extensions to support efficient encoding/decoding of any named types
+  - Support encoding.(Binary|Text)(M|Unm)arshaler interfaces
+  - Support using existence of `IsZero() bool` to determine if a value is a zero value.
+    Analogous to time.Time.IsZero() bool.
+  - Decoding without a schema (into a interface{}).
+    Includes Options to configure what specific map or slice type to use
+    when decoding an encoded list or map into a nil interface{}
+  - Mapping a non-interface type to an interface, so we can decode appropriately
+    into any interface type with a correctly configured non-interface value.
+  - Encode a struct as an array, and decode struct from an array in the data stream
+  - Option to encode struct keys as numbers (instead of strings)
+    (to support structured streams with fields encoded as numeric codes)
+  - Comprehensive support for anonymous fields
+  - Fast (no-reflection) encoding/decoding of common maps and slices
+  - Code-generation for faster performance, supported in go 1.6+
+  - Support binary (e.g. messagepack, cbor) and text (e.g. json) formats
+  - Support indefinite-length formats to enable true streaming
+    (for formats which support it e.g. json, cbor)
+  - Support canonical encoding, where a value is ALWAYS encoded as same sequence of bytes.
+    This mostly applies to maps, where iteration order is non-deterministic.
+  - NIL in data stream decoded as zero value
+  - Never silently skip data when decoding.
+    User decides whether to return an error or silently skip data when keys or indexes
+    in the data stream do not map to fields in the struct.
+  - Detect and error when encoding a cyclic reference (instead of stack overflow shutdown)
+  - Encode/Decode from/to chan types (for iterative streaming support)
+  - Drop-in replacement for encoding/json. `json:` key in struct tag supported.
+  - Provides a RPC Server and Client Codec for net/rpc communication protocol.
+  - Handle unique idiosyncrasies of codecs e.g.
+    - For messagepack, configure how ambiguities in handling raw bytes are resolved
+    - For messagepack, provide rpc server/client codec to support
+      msgpack-rpc protocol defined at:
+      https://github.com/msgpack-rpc/msgpack-rpc/blob/master/spec.md
+
+
+## Extension Support
+
+Users can register a function to handle the encoding or decoding of their
+custom types.
+
+There are no restrictions on what the custom type can be. Some examples:
+
+```go
+    type BisSet   []int
+    type BitSet64 uint64
+    type UUID     string
+    type MyStructWithUnexportedFields struct { a int; b bool; c []int; }
+    type GifImage struct { ... }
+```
+
+As an illustration, MyStructWithUnexportedFields would normally be encoded
+as an empty map because it has no exported fields, while UUID would be
+encoded as a string. However, with extension support, you can encode any of
+these however you like.
+
+There is also seamless support provided for registering an extension (with a
+tag) but letting the encoding mechanism default to the standard way.
+
+
+## Custom Encoding and Decoding
+
+This package maintains symmetry in the encoding and decoding halfs. We
+determine how to encode or decode by walking this decision tree
+
+  - is there an extension registered for the type?
+  - is type a codec.Selfer?
+  - is format binary, and is type a encoding.BinaryMarshaler and BinaryUnmarshaler?
+  - is format specifically json, and is type a encoding/json.Marshaler and Unmarshaler?
+  - is format text-based, and type an encoding.TextMarshaler and TextUnmarshaler?
+  - else we use a pair of functions based on the "kind" of the type e.g. map, slice, int64, etc
+
+This symmetry is important to reduce chances of issues happening because the
+encoding and decoding sides are out of sync e.g. decoded via very specific
+encoding.TextUnmarshaler but encoded via kind-specific generalized mode.
+
+Consequently, if a type only defines one-half of the symmetry (e.g. it
+implements UnmarshalJSON() but not MarshalJSON() ), then that type doesn't
+satisfy the check and we will continue walking down the decision tree.
+
+
+## RPC
+
+RPC Client and Server Codecs are implemented, so the codecs can be used with
+the standard net/rpc package.
+
+
+## Usage
+
+The Handle is SAFE for concurrent READ, but NOT SAFE for concurrent
+modification.
+
+The Encoder and Decoder are NOT safe for concurrent use.
+
+Consequently, the usage model is basically:
+
+  - Create and initialize the Handle before any use.
+    Once created, DO NOT modify it.
+  - Multiple Encoders or Decoders can now use the Handle concurrently.
+    They only read information off the Handle (never write).
+  - However, each Encoder or Decoder MUST not be used concurrently
+  - To re-use an Encoder/Decoder, call Reset(...) on it first.
+    This allows you use state maintained on the Encoder/Decoder.
+
+Sample usage model:
+
+```go
+    // create and configure Handle
+    var (
+      bh codec.BincHandle
+      mh codec.MsgpackHandle
+      ch codec.CborHandle
+    )
+
+    mh.MapType = reflect.TypeOf(map[string]interface{}(nil))
+
+    // configure extensions
+    // e.g. for msgpack, define functions and enable Time support for tag 1
+    // mh.SetExt(reflect.TypeOf(time.Time{}), 1, myExt)
+
+    // create and use decoder/encoder
+    var (
+      r io.Reader
+      w io.Writer
+      b []byte
+      h = &bh // or mh to use msgpack
+    )
+
+    dec = codec.NewDecoder(r, h)
+    dec = codec.NewDecoderBytes(b, h)
+    err = dec.Decode(&v)
+
+    enc = codec.NewEncoder(w, h)
+    enc = codec.NewEncoderBytes(&b, h)
+    err = enc.Encode(v)
+
+    //RPC Server
+    go func() {
+        for {
+            conn, err := listener.Accept()
+            rpcCodec := codec.GoRpc.ServerCodec(conn, h)
+            //OR rpcCodec := codec.MsgpackSpecRpc.ServerCodec(conn, h)
+            rpc.ServeCodec(rpcCodec)
+        }
+    }()
+
+    //RPC Communication (client side)
+    conn, err = net.Dial("tcp", "localhost:5555")
+    rpcCodec := codec.GoRpc.ClientCodec(conn, h)
+    //OR rpcCodec := codec.MsgpackSpecRpc.ClientCodec(conn, h)
+    client := rpc.NewClientWithCodec(rpcCodec)
+```
+
+
+## Running Tests
+
+To run tests, use the following:
+
+```
+    go test
+```
+
+To run the full suite of tests, use the following:
+
+```
+    go test -tags alltests -run Suite
+```
+
+You can run the tag 'codec.safe' to run tests or build in safe mode. e.g.
+
+```
+    go test -tags codec.safe -run Json
+    go test -tags "alltests codec.safe" -run Suite
+```
+
+## Running Benchmarks
+
+```
+    cd bench
+    go test -bench . -benchmem -benchtime 1s
+```
+
+Please see http://github.com/ugorji/go-codec-bench .
+
+
+## Caveats
+
+Struct fields matching the following are ignored during encoding and
+decoding
+
+  - struct tag value set to -
+  - func, complex numbers, unsafe pointers
+  - unexported and not embedded
+  - unexported and embedded and not struct kind
+  - unexported and embedded pointers (from go1.10)
+
+Every other field in a struct will be encoded/decoded.
+
+Embedded fields are encoded as if they exist in the top-level struct, with
+some caveats. See Encode documentation.
+
+## Exported Package API
+
+```go
+const CborStreamBytes byte = 0x5f ...
+const GenVersion = 25
+var SelfExt = &extFailWrapper{}
+var GoRpc goRpc
+var MsgpackSpecRpc msgpackSpecRpc
+func GenHelper() (g genHelper)
+type BasicHandle struct{ ... }
+type BincHandle struct{ ... }
+type BytesExt interface{ ... }
+type CborHandle struct{ ... }
+type DecodeOptions struct{ ... }
+type Decoder struct{ ... }
+    func NewDecoder(r io.Reader, h Handle) *Decoder
+    func NewDecoderBytes(in []byte, h Handle) *Decoder
+    func NewDecoderString(s string, h Handle) *Decoder
+type EncodeOptions struct{ ... }
+type Encoder struct{ ... }
+    func NewEncoder(w io.Writer, h Handle) *Encoder
+    func NewEncoderBytes(out *[]byte, h Handle) *Encoder
+type Ext interface{ ... }
+type Handle interface{ ... }
+type InterfaceExt interface{ ... }
+type JsonHandle struct{ ... }
+type MapBySlice interface{ ... }
+type MissingFielder interface{ ... }
+type MsgpackHandle struct{ ... }
+type MsgpackSpecRpcMultiArgs []interface{}
+type RPCOptions struct{ ... }
+type Raw []byte
+type RawExt struct{ ... }
+type Rpc interface{ ... }
+type Selfer interface{ ... }
+type SimpleHandle struct{ ... }
+type TypeInfos struct{ ... }
+    func NewTypeInfos(tags []string) *TypeInfos
+```

vendor/github.com/ugorji/go/codec/build.sh

@@ -0,0 +1,368 @@
+#!/bin/bash
+
+# Run all the different permutations of all the tests and other things
+# This helps ensure that nothing gets broken.
+
+_tests() {
+    local vet="" # TODO: make it off
+    local gover=$( ${gocmd} version | cut -f 3 -d ' ' )
+    [[ $( ${gocmd} version ) == *"gccgo"* ]] && zcover=0
+    [[ $( ${gocmd} version ) == *"gollvm"* ]] && zcover=0
+    case $gover in
+        go1.[7-9]*|go1.1[0-9]*|go2.*|devel*) true ;;
+        *) return 1
+    esac
+    # note that codecgen requires fastpath, so you cannot do "codecgen codec.notfastpath"
+    # we test the following permutations wnich all execute different code paths as below.
+    echo "TestCodecSuite: (fastpath/unsafe), (!fastpath/unsafe), (fastpath/!unsafe), (!fastpath/!unsafe), (codecgen/unsafe)"
+    local echo=1
+    local nc=2 # count
+    local cpus="1,$(nproc)"
+    # if using the race detector, then set nc to
+    if [[ " ${zargs[@]} " =~ "-race" ]]; then
+        cpus="$(nproc)"
+    fi
+    local a=( "" "codec.notfastpath" "codec.safe" "codec.notfastpath codec.safe"  "codecgen" )
+    local b=()
+    local c=()
+    for i in "${a[@]}"
+    do
+        local i2=${i:-default}
+        [[ "$zwait" == "1" ]] && echo ">>>> TAGS: 'alltests $i'; RUN: 'TestCodecSuite'"
+        [[ "$zcover" == "1" ]] && c=( -coverprofile "${i2// /-}.cov.out" )
+        true &&
+            ${gocmd} vet -printfuncs "errorf" "$@" &&
+            if [[ "$echo" == 1 ]]; then set -o xtrace; fi &&
+            ${gocmd} test ${zargs[*]} ${ztestargs[*]} -vet "$vet" -tags "alltests $i" -count $nc -cpu $cpus -run "TestCodecSuite" "${c[@]}" "$@" &
+        if [[ "$echo" == 1 ]]; then set +o xtrace; fi
+        b+=("${i2// /-}.cov.out")
+        [[ "$zwait" == "1" ]] && wait
+            
+        # if [[ "$?" != 0 ]]; then return 1; fi
+    done
+    if [[ "$zextra" == "1" ]]; then
+        [[ "$zwait" == "1" ]] && echo ">>>> TAGS: 'codec.notfastpath x'; RUN: 'Test.*X$'"
+        [[ "$zcover" == "1" ]] && c=( -coverprofile "x.cov.out" )
+        ${gocmd} test ${zargs[*]} ${ztestargs[*]} -vet "$vet" -tags "codec.notfastpath x" -count $nc -run 'Test.*X$' "${c[@]}" &
+        b+=("x.cov.out")
+        [[ "$zwait" == "1" ]] && wait
+    fi
+    wait
+    # go tool cover is not supported for gccgo, gollvm, other non-standard go compilers
+    [[ "$zcover" == "1" ]] &&
+        command -v gocovmerge &&
+        gocovmerge "${b[@]}" > __merge.cov.out &&
+        ${gocmd} tool cover -html=__merge.cov.out
+}
+
+# is a generation needed?
+_ng() {
+    local a="$1"
+    if [[ ! -e "$a" ]]; then echo 1; return; fi 
+    for i in `ls -1 *.go.tmpl gen.go values_test.go`
+    do
+        if [[ "$a" -ot "$i" ]]; then echo 1; return; fi 
+    done
+}
+
+_prependbt() {
+    cat > ${2} <<EOF
+// +build generated
+
+EOF
+    cat ${1} >> ${2}
+    rm -f ${1}
+}
+
+# _build generates fast-path.go and gen-helper.go.
+_build() {
+    if ! [[ "${zforce}" || $(_ng "fast-path.generated.go") || $(_ng "gen-helper.generated.go") || $(_ng "gen.generated.go") ]]; then return 0; fi 
+    
+    if [ "${zbak}" ]; then
+        _zts=`date '+%m%d%Y_%H%M%S'`
+        _gg=".generated.go"
+        [ -e "gen-helper${_gg}" ] && mv gen-helper${_gg} gen-helper${_gg}__${_zts}.bak
+        [ -e "fast-path${_gg}" ] && mv fast-path${_gg} fast-path${_gg}__${_zts}.bak
+        [ -e "gen${_gg}" ] && mv gen${_gg} gen${_gg}__${_zts}.bak
+    fi 
+    rm -f gen-helper.generated.go fast-path.generated.go gen.generated.go \
+       *safe.generated.go *_generated_test.go *.generated_ffjson_expose.go 
+
+    cat > gen.generated.go <<EOF
+// +build codecgen.exec
+
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+package codec
+
+// DO NOT EDIT. THIS FILE IS AUTO-GENERATED FROM gen-dec-(map|array).go.tmpl
+
+const genDecMapTmpl = \`
+EOF
+    cat >> gen.generated.go < gen-dec-map.go.tmpl
+    cat >> gen.generated.go <<EOF
+\`
+
+const genDecListTmpl = \`
+EOF
+    cat >> gen.generated.go < gen-dec-array.go.tmpl
+    cat >> gen.generated.go <<EOF
+\`
+
+const genEncChanTmpl = \`
+EOF
+    cat >> gen.generated.go < gen-enc-chan.go.tmpl
+    cat >> gen.generated.go <<EOF
+\`
+EOF
+    cat > gen-from-tmpl.codec.generated.go <<EOF
+package codec 
+func GenRunTmpl2Go(in, out string) { genRunTmpl2Go(in, out) }
+func GenRunSortTmpl2Go(in, out string) { genRunSortTmpl2Go(in, out) }
+EOF
+
+    # stub xxxRv and xxxRvSlice creation, before you create it
+    cat > gen-from-tmpl.sort-slice-stubs.generated.go <<EOF
+// +build codecgen.sort_slice
+
+package codec
+
+import "reflect"
+import "time"
+
+EOF
+
+    for i in string bool uint64 int64 float64 bytes time; do
+        local i2=$i
+        case $i in
+            'time' ) i2="time.Time";;
+            'bytes' ) i2="[]byte";;
+        esac
+
+        cat >> gen-from-tmpl.sort-slice-stubs.generated.go <<EOF
+type ${i}Rv struct { v ${i2}; r reflect.Value }
+
+type ${i}RvSlice []${i}Rv
+
+func (${i}RvSlice) Len() int { return 0 }
+func (${i}RvSlice) Less(i, j int) bool { return false }
+func (${i}RvSlice) Swap(i, j int) {}
+
+type ${i}Intf struct { v ${i2}; i interface{} }
+
+type ${i}IntfSlice []${i}Intf
+
+func (${i}IntfSlice) Len() int { return 0 }
+func (${i}IntfSlice) Less(i, j int) bool { return false }
+func (${i}IntfSlice) Swap(i, j int) {}
+
+EOF
+    done
+
+    sed -e 's+// __DO_NOT_REMOVE__NEEDED_FOR_REPLACING__IMPORT_PATH__FOR_CODEC_BENCH__+import . "github.com/ugorji/go/codec"+' \
+        shared_test.go > bench/shared_test.go
+
+    # explicitly return 0 if this passes, else return 1
+    local btags="codec.notfastpath codec.safe codecgen.exec"
+    rm -f sort-slice.generated.go fast-path.generated.go gen-helper.generated.go mammoth_generated_test.go mammoth2_generated_test.go
+    
+    cat > gen-from-tmpl.sort-slice.generated.go <<EOF
+// +build ignore
+
+package main
+
+import "${zpkg}"
+
+func main() {
+codec.GenRunSortTmpl2Go("sort-slice.go.tmpl", "sort-slice.generated.go")
+}
+EOF
+
+    ${gocmd} run -tags "$btags codecgen.sort_slice" gen-from-tmpl.sort-slice.generated.go || return 1
+    rm -f gen-from-tmpl.sort-slice.generated.go
+    
+    cat > gen-from-tmpl.generated.go <<EOF
+// +build ignore
+
+package main
+
+import "${zpkg}"
+
+func main() {
+codec.GenRunTmpl2Go("fast-path.go.tmpl", "fast-path.generated.go")
+codec.GenRunTmpl2Go("gen-helper.go.tmpl", "gen-helper.generated.go")
+codec.GenRunTmpl2Go("mammoth-test.go.tmpl", "mammoth_generated_test.go")
+codec.GenRunTmpl2Go("mammoth2-test.go.tmpl", "mammoth2_generated_test.go")
+}
+EOF
+
+    ${gocmd} run -tags "$btags" gen-from-tmpl.generated.go || return 1
+    rm -f gen-from-tmpl.generated.go
+    
+    rm -f gen-from-tmpl.*generated.go
+    return 0
+}
+
+_codegenerators() {
+    local c5="_generated_test.go"
+    local c7="$PWD/codecgen"
+    local c8="$c7/__codecgen"
+    local c9="codecgen-scratch.go"
+
+    if ! [[ $zforce || $(_ng "values_codecgen${c5}") ]]; then return 0; fi
+    
+    # Note: ensure you run the codecgen for this codebase/directory i.e. ./codecgen/codecgen
+    true &&
+        echo "codecgen ... " &&
+        if [[ $zforce || ! -f "$c8" || "$c7/gen.go" -nt "$c8" ]]; then
+            echo "rebuilding codecgen ... " && ( cd codecgen && ${gocmd} build -o $c8 ${zargs[*]} . )
+        fi &&
+        $c8 -rt 'codecgen' -t 'codecgen generated' -o "values_codecgen${c5}" -d 19780 "$zfin" "$zfin2" &&
+        cp mammoth2_generated_test.go $c9 &&
+        $c8 -t 'codecgen,!codec.notfastpath,!codec.notmammoth generated,!codec.notfastpath,!codec.notmammoth' -o "mammoth2_codecgen${c5}" -d 19781 "mammoth2_generated_test.go" &&
+        rm -f $c9 &&
+        echo "generators done!" 
+}
+
+_prebuild() {
+    echo "prebuild: zforce: $zforce"
+    local d="$PWD"
+    local zfin="test_values.generated.go"
+    local zfin2="test_values_flex.generated.go"
+    local zpkg="github.com/ugorji/go/codec"
+    local returncode=1
+
+    # zpkg=${d##*/src/}
+    # zgobase=${d%%/src/*}
+    # rm -f *_generated_test.go 
+    rm -f codecgen-*.go &&
+        _build &&
+        cp $d/values_test.go $d/$zfin &&
+        cp $d/values_flex_test.go $d/$zfin2 &&
+        _codegenerators &&
+        if [[ "$(type -t _codegenerators_external )" = "function" ]]; then _codegenerators_external ; fi &&
+        if [[ $zforce ]]; then ${gocmd} install ${zargs[*]} .; fi &&
+        returncode=0 &&
+        echo "prebuild done successfully"
+    rm -f $d/$zfin $d/$zfin2
+    return $returncode
+    # unset zfin zfin2 zpkg
+}
+
+_make() {
+    local makeforce=${zforce}
+    zforce=1
+    (cd codecgen && ${gocmd} install ${zargs[*]} .) && _prebuild && ${gocmd} install ${zargs[*]} .
+    zforce=${makeforce}
+}
+
+_clean() {
+    rm -f \
+       gen-from-tmpl.*generated.go \
+       codecgen-*.go \
+       test_values.generated.go test_values_flex.generated.go
+}
+
+_release() {
+    local reply
+    read -p "Pre-release validation takes a few minutes and MUST be run from within GOPATH/src. Confirm y/n? " -n 1 -r reply
+    echo
+    if [[ ! $reply =~ ^[Yy]$ ]]; then return 1; fi
+
+    # expects GOROOT, GOROOT_BOOTSTRAP to have been set.
+    if [[ -z "${GOROOT// }" || -z "${GOROOT_BOOTSTRAP// }" ]]; then return 1; fi
+    # (cd $GOROOT && git checkout -f master && git pull && git reset --hard)
+    (cd $GOROOT && git pull)
+    local f=`pwd`/make.release.out
+    cat > $f <<EOF
+========== `date` ===========
+EOF
+    # # go 1.6 and below kept giving memory errors on Mac OS X during SDK build or go run execution,
+    # # that is fine, as we only explicitly test the last 3 releases and tip (2 years).
+    local makeforce=${zforce}
+    zforce=1
+    for i in 1.10 1.11 1.12 master
+    do
+        echo "*********** $i ***********" >>$f
+        if [[ "$i" != "master" ]]; then i="release-branch.go$i"; fi
+        (false ||
+             (echo "===== BUILDING GO SDK for branch: $i ... =====" &&
+                  cd $GOROOT &&
+                  git checkout -f $i && git reset --hard && git clean -f . &&
+                  cd src && ./make.bash >>$f 2>&1 && sleep 1 ) ) &&
+            echo "===== GO SDK BUILD DONE =====" &&
+            _prebuild &&
+            echo "===== PREBUILD DONE with exit: $? =====" &&
+            _tests "$@"
+        if [[ "$?" != 0 ]]; then return 1; fi
+    done
+    zforce=${makeforce}
+    echo "++++++++ RELEASE TEST SUITES ALL PASSED ++++++++"
+}
+
+_usage() {
+    # hidden args:
+    # -pf [p=prebuild (f=force)]
+    
+    cat <<EOF
+primary usage: $0 
+    -[tesow m n l d]   -> [t=tests (e=extra, s=short, o=cover, w=wait), m=make, n=inlining diagnostics, l=mid-stack inlining, d=race detector]
+    -v                   -> v=verbose
+EOF
+    if [[ "$(type -t _usage_run)" = "function" ]]; then _usage_run ; fi
+}
+
+_main() {
+    if [[ -z "$1" ]]; then _usage; return 1; fi
+    local x # determines the main action to run in this build
+    local zforce # force
+    local zcover # generate cover profile and show in browser when done
+    local zwait # run tests in sequence, not parallel ie wait for one to finish before starting another
+    local zextra # means run extra (python based tests, etc) during testing
+    
+    local ztestargs=()
+    local zargs=()
+    local zverbose=()
+    local zbenchflags=""
+
+    local gocmd=${MYGOCMD:-go}
+    
+    OPTIND=1
+    while getopts ":cetmnrgpfvldsowkxyzb:" flag
+    do
+        case "x$flag" in
+            'xo') zcover=1 ;;
+            'xe') zextra=1 ;;
+            'xw') zwait=1 ;;
+            'xf') zforce=1 ;;
+            'xs') ztestargs+=("-short") ;;
+            'xv') zverbose+=(1) ;;
+            'xl') zargs+=("-gcflags"); zargs+=("-l=4") ;;
+            'xn') zargs+=("-gcflags"); zargs+=("-m=2") ;;
+            'xd') zargs+=("-race") ;;
+            'xb') x='b'; zbenchflags=${OPTARG} ;;
+            x\?) _usage; return 1 ;;
+            *) x=$flag ;;
+        esac
+    done
+    shift $((OPTIND-1))
+    # echo ">>>> _main: extra args: $@"
+    case "x$x" in
+        'xt') _tests "$@" ;;
+        'xm') _make "$@" ;;
+        'xr') _release "$@" ;;
+        'xg') _go ;;
+        'xp') _prebuild "$@" ;;
+        'xc') _clean "$@" ;;
+        'xx') _analyze_checks "$@" ;;
+        'xy') _analyze_debug_types "$@" ;;
+        'xz') _analyze_do_inlining_and_more "$@" ;;
+        'xk') _go_compiler_validation_suite ;;
+        'xb') _bench "$@" ;;
+    esac
+    # unset zforce zargs zbenchflags
+}
+
+[ "." = `dirname $0` ] && _main "$@"
+

vendor/github.com/ugorji/go/codec/cbor.go

@@ -0,0 +1,949 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+package codec
+
+import (
+	"math"
+	"reflect"
+	"time"
+)
+
+// major
+const (
+	cborMajorUint byte = iota
+	cborMajorNegInt
+	cborMajorBytes
+	cborMajorString
+	cborMajorArray
+	cborMajorMap
+	cborMajorTag
+	cborMajorSimpleOrFloat
+)
+
+// simple
+const (
+	cborBdFalse byte = 0xf4 + iota
+	cborBdTrue
+	cborBdNil
+	cborBdUndefined
+	cborBdExt
+	cborBdFloat16
+	cborBdFloat32
+	cborBdFloat64
+)
+
+// indefinite
+const (
+	cborBdIndefiniteBytes  byte = 0x5f
+	cborBdIndefiniteString byte = 0x7f
+	cborBdIndefiniteArray  byte = 0x9f
+	cborBdIndefiniteMap    byte = 0xbf
+	cborBdBreak            byte = 0xff
+)
+
+// These define some in-stream descriptors for
+// manual encoding e.g. when doing explicit indefinite-length
+const (
+	CborStreamBytes  byte = 0x5f
+	CborStreamString byte = 0x7f
+	CborStreamArray  byte = 0x9f
+	CborStreamMap    byte = 0xbf
+	CborStreamBreak  byte = 0xff
+)
+
+// base values
+const (
+	cborBaseUint   byte = 0x00
+	cborBaseNegInt byte = 0x20
+	cborBaseBytes  byte = 0x40
+	cborBaseString byte = 0x60
+	cborBaseArray  byte = 0x80
+	cborBaseMap    byte = 0xa0
+	cborBaseTag    byte = 0xc0
+	cborBaseSimple byte = 0xe0
+)
+
+// const (
+// 	cborSelfDesrTag  byte = 0xd9
+// 	cborSelfDesrTag2 byte = 0xd9
+// 	cborSelfDesrTag3 byte = 0xf7
+// )
+
+var (
+	cbordescSimpleNames = map[byte]string{
+		cborBdNil:     "nil",
+		cborBdFalse:   "false",
+		cborBdTrue:    "true",
+		cborBdFloat16: "float",
+		cborBdFloat32: "float",
+		cborBdFloat64: "float",
+		cborBdBreak:   "break",
+	}
+	cbordescIndefNames = map[byte]string{
+		cborBdIndefiniteBytes:  "bytes*",
+		cborBdIndefiniteString: "string*",
+		cborBdIndefiniteArray:  "array*",
+		cborBdIndefiniteMap:    "map*",
+	}
+	cbordescMajorNames = map[byte]string{
+		cborMajorUint:          "(u)int",
+		cborMajorNegInt:        "int",
+		cborMajorBytes:         "bytes",
+		cborMajorString:        "string",
+		cborMajorArray:         "array",
+		cborMajorMap:           "map",
+		cborMajorTag:           "tag",
+		cborMajorSimpleOrFloat: "simple",
+	}
+)
+
+func cbordesc(bd byte) (s string) {
+	bm := bd >> 5
+	if bm == cborMajorSimpleOrFloat {
+		s = cbordescSimpleNames[bd]
+	} else {
+		s = cbordescMajorNames[bm]
+		if s == "" {
+			s = cbordescIndefNames[bd]
+		}
+	}
+	if s == "" {
+		s = "unknown"
+	}
+	return
+}
+
+// -------------------
+
+type cborEncDriver struct {
+	noBuiltInTypes
+	encDriverNoState
+	encDriverNoopContainerWriter
+	h *CborHandle
+
+	e Encoder
+}
+
+func (e *cborEncDriver) encoder() *Encoder {
+	return &e.e
+}
+
+func (e *cborEncDriver) EncodeNil() {
+	e.e.encWr.writen1(cborBdNil)
+}
+
+func (e *cborEncDriver) EncodeBool(b bool) {
+	if b {
+		e.e.encWr.writen1(cborBdTrue)
+	} else {
+		e.e.encWr.writen1(cborBdFalse)
+	}
+}
+
+func (e *cborEncDriver) EncodeFloat32(f float32) {
+	b := math.Float32bits(f)
+	if e.h.OptimumSize {
+		if h := floatToHalfFloatBits(b); halfFloatToFloatBits(h) == b {
+			e.e.encWr.writen1(cborBdFloat16)
+			bigen.writeUint16(e.e.w(), h)
+			return
+		}
+	}
+	e.e.encWr.writen1(cborBdFloat32)
+	bigen.writeUint32(e.e.w(), b)
+}
+
+func (e *cborEncDriver) EncodeFloat64(f float64) {
+	if e.h.OptimumSize {
+		if f32 := float32(f); float64(f32) == f {
+			e.EncodeFloat32(f32)
+			return
+		}
+	}
+	e.e.encWr.writen1(cborBdFloat64)
+	bigen.writeUint64(e.e.w(), math.Float64bits(f))
+}
+
+func (e *cborEncDriver) encUint(v uint64, bd byte) {
+	if v <= 0x17 {
+		e.e.encWr.writen1(byte(v) + bd)
+	} else if v <= math.MaxUint8 {
+		e.e.encWr.writen2(bd+0x18, uint8(v))
+	} else if v <= math.MaxUint16 {
+		e.e.encWr.writen1(bd + 0x19)
+		bigen.writeUint16(e.e.w(), uint16(v))
+	} else if v <= math.MaxUint32 {
+		e.e.encWr.writen1(bd + 0x1a)
+		bigen.writeUint32(e.e.w(), uint32(v))
+	} else { // if v <= math.MaxUint64 {
+		e.e.encWr.writen1(bd + 0x1b)
+		bigen.writeUint64(e.e.w(), v)
+	}
+}
+
+func (e *cborEncDriver) EncodeInt(v int64) {
+	if v < 0 {
+		e.encUint(uint64(-1-v), cborBaseNegInt)
+	} else {
+		e.encUint(uint64(v), cborBaseUint)
+	}
+}
+
+func (e *cborEncDriver) EncodeUint(v uint64) {
+	e.encUint(v, cborBaseUint)
+}
+
+func (e *cborEncDriver) encLen(bd byte, length int) {
+	e.encUint(uint64(length), bd)
+}
+
+func (e *cborEncDriver) EncodeTime(t time.Time) {
+	if t.IsZero() {
+		e.EncodeNil()
+	} else if e.h.TimeRFC3339 {
+		e.encUint(0, cborBaseTag)
+		e.encStringBytesS(cborBaseString, t.Format(time.RFC3339Nano))
+	} else {
+		e.encUint(1, cborBaseTag)
+		t = t.UTC().Round(time.Microsecond)
+		sec, nsec := t.Unix(), uint64(t.Nanosecond())
+		if nsec == 0 {
+			e.EncodeInt(sec)
+		} else {
+			e.EncodeFloat64(float64(sec) + float64(nsec)/1e9)
+		}
+	}
+}
+
+func (e *cborEncDriver) EncodeExt(rv interface{}, basetype reflect.Type, xtag uint64, ext Ext) {
+	e.encUint(uint64(xtag), cborBaseTag)
+	if ext == SelfExt {
+		e.e.encodeValue(baseRV(rv), e.h.fnNoExt(basetype))
+	} else if v := ext.ConvertExt(rv); v == nil {
+		e.EncodeNil()
+	} else {
+		e.e.encode(v)
+	}
+}
+
+func (e *cborEncDriver) EncodeRawExt(re *RawExt) {
+	e.encUint(uint64(re.Tag), cborBaseTag)
+	// only encodes re.Value (never re.Data)
+	if re.Value != nil {
+		e.e.encode(re.Value)
+	} else {
+		e.EncodeNil()
+	}
+}
+
+func (e *cborEncDriver) WriteArrayStart(length int) {
+	if e.h.IndefiniteLength {
+		e.e.encWr.writen1(cborBdIndefiniteArray)
+	} else {
+		e.encLen(cborBaseArray, length)
+	}
+}
+
+func (e *cborEncDriver) WriteMapStart(length int) {
+	if e.h.IndefiniteLength {
+		e.e.encWr.writen1(cborBdIndefiniteMap)
+	} else {
+		e.encLen(cborBaseMap, length)
+	}
+}
+
+func (e *cborEncDriver) WriteMapEnd() {
+	if e.h.IndefiniteLength {
+		e.e.encWr.writen1(cborBdBreak)
+	}
+}
+
+func (e *cborEncDriver) WriteArrayEnd() {
+	if e.h.IndefiniteLength {
+		e.e.encWr.writen1(cborBdBreak)
+	}
+}
+
+func (e *cborEncDriver) EncodeString(v string) {
+	bb := cborBaseString
+	if e.h.StringToRaw {
+		bb = cborBaseBytes
+	}
+	e.encStringBytesS(bb, v)
+}
+
+func (e *cborEncDriver) EncodeStringBytesRaw(v []byte) {
+	if v == nil {
+		e.EncodeNil()
+	} else {
+		e.encStringBytesS(cborBaseBytes, stringView(v))
+	}
+}
+
+func (e *cborEncDriver) encStringBytesS(bb byte, v string) {
+	if e.h.IndefiniteLength {
+		if bb == cborBaseBytes {
+			e.e.encWr.writen1(cborBdIndefiniteBytes)
+		} else {
+			e.e.encWr.writen1(cborBdIndefiniteString)
+		}
+		var vlen uint = uint(len(v))
+		blen := vlen / 4
+		if blen == 0 {
+			blen = 64
+		} else if blen > 1024 {
+			blen = 1024
+		}
+		for i := uint(0); i < vlen; {
+			var v2 string
+			i2 := i + blen
+			if i2 >= i && i2 < vlen {
+				v2 = v[i:i2]
+			} else {
+				v2 = v[i:]
+			}
+			e.encLen(bb, len(v2))
+			e.e.encWr.writestr(v2)
+			i = i2
+		}
+		e.e.encWr.writen1(cborBdBreak)
+	} else {
+		e.encLen(bb, len(v))
+		e.e.encWr.writestr(v)
+	}
+}
+
+// ----------------------
+
+type cborDecDriver struct {
+	decDriverNoopContainerReader
+	decDriverNoopNumberHelper
+	h *CborHandle
+	bdAndBdread
+	st bool // skip tags
+	_  bool // found nil
+	noBuiltInTypes
+	d Decoder
+}
+
+func (d *cborDecDriver) decoder() *Decoder {
+	return &d.d
+}
+
+func (d *cborDecDriver) descBd() string {
+	return sprintf("%v (%s)", d.bd, cbordesc(d.bd))
+}
+
+func (d *cborDecDriver) readNextBd() {
+	d.bd = d.d.decRd.readn1()
+	d.bdRead = true
+}
+
+func (d *cborDecDriver) advanceNil() (null bool) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
+	if d.bd == cborBdNil || d.bd == cborBdUndefined {
+		d.bdRead = false
+		return true // null = true
+	}
+	return
+}
+
+func (d *cborDecDriver) TryNil() bool {
+	return d.advanceNil()
+}
+
+// skipTags is called to skip any tags in the stream.
+//
+// Since any value can be tagged, then we should call skipTags
+// before any value is decoded.
+//
+// By definition, skipTags should not be called before
+// checking for break, or nil or undefined.
+func (d *cborDecDriver) skipTags() {
+	for d.bd>>5 == cborMajorTag {
+		d.decUint()
+		d.bd = d.d.decRd.readn1()
+	}
+}
+
+func (d *cborDecDriver) ContainerType() (vt valueType) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
+	if d.st {
+		d.skipTags()
+	}
+	if d.bd == cborBdNil {
+		d.bdRead = false // always consume nil after seeing it in container type
+		return valueTypeNil
+	}
+	major := d.bd >> 5
+	if major == cborMajorBytes {
+		return valueTypeBytes
+	} else if major == cborMajorString {
+		return valueTypeString
+	} else if major == cborMajorArray {
+		return valueTypeArray
+	} else if major == cborMajorMap {
+		return valueTypeMap
+	}
+	return valueTypeUnset
+}
+
+func (d *cborDecDriver) CheckBreak() (v bool) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
+	if d.bd == cborBdBreak {
+		d.bdRead = false
+		v = true
+	}
+	return
+}
+
+func (d *cborDecDriver) decUint() (ui uint64) {
+	v := d.bd & 0x1f
+	if v <= 0x17 {
+		ui = uint64(v)
+	} else if v == 0x18 {
+		ui = uint64(d.d.decRd.readn1())
+	} else if v == 0x19 {
+		ui = uint64(bigen.Uint16(d.d.decRd.readn2()))
+	} else if v == 0x1a {
+		ui = uint64(bigen.Uint32(d.d.decRd.readn4()))
+	} else if v == 0x1b {
+		ui = uint64(bigen.Uint64(d.d.decRd.readn8()))
+	} else {
+		d.d.errorf("invalid descriptor decoding uint: %x/%s", d.bd, cbordesc(d.bd))
+	}
+	return
+}
+
+func (d *cborDecDriver) decLen() int {
+	return int(d.decUint())
+}
+
+func (d *cborDecDriver) decAppendIndefiniteBytes(bs []byte) []byte {
+	d.bdRead = false
+	for !d.CheckBreak() {
+		if major := d.bd >> 5; major != cborMajorBytes && major != cborMajorString {
+			d.d.errorf("invalid indefinite string/bytes %x (%s); got major %v, expected %v or %v",
+				d.bd, cbordesc(d.bd), major, cborMajorBytes, cborMajorString)
+		}
+		n := uint(d.decLen())
+		oldLen := uint(len(bs))
+		newLen := oldLen + n
+		if newLen > uint(cap(bs)) {
+			bs2 := make([]byte, newLen, 2*uint(cap(bs))+n)
+			copy(bs2, bs)
+			bs = bs2
+		} else {
+			bs = bs[:newLen]
+		}
+		d.d.decRd.readb(bs[oldLen:newLen])
+		d.bdRead = false
+	}
+	d.bdRead = false
+	return bs
+}
+
+func (d *cborDecDriver) decFloat() (f float64, ok bool) {
+	ok = true
+	switch d.bd {
+	case cborBdFloat16:
+		f = float64(math.Float32frombits(halfFloatToFloatBits(bigen.Uint16(d.d.decRd.readn2()))))
+	case cborBdFloat32:
+		f = float64(math.Float32frombits(bigen.Uint32(d.d.decRd.readn4())))
+	case cborBdFloat64:
+		f = math.Float64frombits(bigen.Uint64(d.d.decRd.readn8()))
+	default:
+		ok = false
+	}
+	return
+}
+
+func (d *cborDecDriver) decInteger() (ui uint64, neg, ok bool) {
+	ok = true
+	switch d.bd >> 5 {
+	case cborMajorUint:
+		ui = d.decUint()
+	case cborMajorNegInt:
+		ui = d.decUint()
+		neg = true
+	default:
+		ok = false
+	}
+	return
+}
+
+func (d *cborDecDriver) DecodeInt64() (i int64) {
+	if d.advanceNil() {
+		return
+	}
+	if d.st {
+		d.skipTags()
+	}
+	i = decNegintPosintFloatNumberHelper{&d.d}.int64(d.decInteger())
+	d.bdRead = false
+	return
+}
+
+func (d *cborDecDriver) DecodeUint64() (ui uint64) {
+	if d.advanceNil() {
+		return
+	}
+	if d.st {
+		d.skipTags()
+	}
+	ui = decNegintPosintFloatNumberHelper{&d.d}.uint64(d.decInteger())
+	d.bdRead = false
+	return
+}
+
+func (d *cborDecDriver) DecodeFloat64() (f float64) {
+	if d.advanceNil() {
+		return
+	}
+	if d.st {
+		d.skipTags()
+	}
+	f = decNegintPosintFloatNumberHelper{&d.d}.float64(d.decFloat())
+	d.bdRead = false
+	return
+}
+
+// bool can be decoded from bool only (single byte).
+func (d *cborDecDriver) DecodeBool() (b bool) {
+	if d.advanceNil() {
+		return
+	}
+	if d.st {
+		d.skipTags()
+	}
+	if d.bd == cborBdTrue {
+		b = true
+	} else if d.bd == cborBdFalse {
+	} else {
+		d.d.errorf("not bool - %s %x/%s", msgBadDesc, d.bd, cbordesc(d.bd))
+	}
+	d.bdRead = false
+	return
+}
+
+func (d *cborDecDriver) ReadMapStart() (length int) {
+	if d.advanceNil() {
+		return containerLenNil
+	}
+	if d.st {
+		d.skipTags()
+	}
+	d.bdRead = false
+	if d.bd == cborBdIndefiniteMap {
+		return containerLenUnknown
+	}
+	if d.bd>>5 != cborMajorMap {
+		d.d.errorf("error reading map; got major type: %x, expected %x/%s", d.bd>>5, cborMajorMap, cbordesc(d.bd))
+	}
+	return d.decLen()
+}
+
+func (d *cborDecDriver) ReadArrayStart() (length int) {
+	if d.advanceNil() {
+		return containerLenNil
+	}
+	if d.st {
+		d.skipTags()
+	}
+	d.bdRead = false
+	if d.bd == cborBdIndefiniteArray {
+		return containerLenUnknown
+	}
+	if d.bd>>5 != cborMajorArray {
+		d.d.errorf("invalid array; got major type: %x, expect: %x/%s", d.bd>>5, cborMajorArray, cbordesc(d.bd))
+	}
+	return d.decLen()
+}
+
+func (d *cborDecDriver) DecodeBytes(bs []byte) (bsOut []byte) {
+	d.d.decByteState = decByteStateNone
+	if d.advanceNil() {
+		return
+	}
+	if d.st {
+		d.skipTags()
+	}
+	if d.bd == cborBdIndefiniteBytes || d.bd == cborBdIndefiniteString {
+		d.bdRead = false
+		if bs == nil {
+			d.d.decByteState = decByteStateReuseBuf
+			return d.decAppendIndefiniteBytes(d.d.b[:0])
+		}
+		return d.decAppendIndefiniteBytes(bs[:0])
+	}
+	if d.bd == cborBdIndefiniteArray {
+		d.bdRead = false
+		if bs == nil {
+			d.d.decByteState = decByteStateReuseBuf
+			bs = d.d.b[:0]
+		} else {
+			bs = bs[:0]
+		}
+		for !d.CheckBreak() {
+			bs = append(bs, uint8(chkOvf.UintV(d.DecodeUint64(), 8)))
+		}
+		return bs
+	}
+	if d.bd>>5 == cborMajorArray {
+		d.bdRead = false
+		if bs == nil {
+			d.d.decByteState = decByteStateReuseBuf
+			bs = d.d.b[:]
+		}
+		slen := d.decLen()
+		var changed bool
+		if bs, changed = usableByteSlice(bs, slen); changed {
+			d.d.decByteState = decByteStateNone
+		}
+		for i := 0; i < len(bs); i++ {
+			bs[i] = uint8(chkOvf.UintV(d.DecodeUint64(), 8))
+		}
+		return bs
+	}
+	clen := d.decLen()
+	d.bdRead = false
+	if d.d.zerocopy() {
+		d.d.decByteState = decByteStateZerocopy
+		return d.d.decRd.rb.readx(uint(clen))
+	}
+	if bs == nil {
+		d.d.decByteState = decByteStateReuseBuf
+		bs = d.d.b[:]
+	}
+	return decByteSlice(d.d.r(), clen, d.h.MaxInitLen, bs)
+}
+
+func (d *cborDecDriver) DecodeStringAsBytes() (s []byte) {
+	return d.DecodeBytes(nil)
+}
+
+func (d *cborDecDriver) DecodeTime() (t time.Time) {
+	if d.advanceNil() {
+		return
+	}
+	if d.bd>>5 != cborMajorTag {
+		d.d.errorf("error reading tag; expected major type: %x, got: %x", cborMajorTag, d.bd>>5)
+	}
+	xtag := d.decUint()
+	d.bdRead = false
+	return d.decodeTime(xtag)
+}
+
+func (d *cborDecDriver) decodeTime(xtag uint64) (t time.Time) {
+	switch xtag {
+	case 0:
+		var err error
+		t, err = time.Parse(time.RFC3339, stringView(d.DecodeStringAsBytes()))
+		d.d.onerror(err)
+	case 1:
+		f1, f2 := math.Modf(d.DecodeFloat64())
+		t = time.Unix(int64(f1), int64(f2*1e9))
+	default:
+		d.d.errorf("invalid tag for time.Time - expecting 0 or 1, got 0x%x", xtag)
+	}
+	t = t.UTC().Round(time.Microsecond)
+	return
+}
+
+func (d *cborDecDriver) DecodeExt(rv interface{}, basetype reflect.Type, xtag uint64, ext Ext) {
+	if d.advanceNil() {
+		return
+	}
+	if d.bd>>5 != cborMajorTag {
+		d.d.errorf("error reading tag; expected major type: %x, got: %x", cborMajorTag, d.bd>>5)
+	}
+	realxtag := d.decUint()
+	d.bdRead = false
+	if ext == nil {
+		re := rv.(*RawExt)
+		re.Tag = realxtag
+		d.d.decode(&re.Value)
+	} else if xtag != realxtag {
+		d.d.errorf("Wrong extension tag. Got %b. Expecting: %v", realxtag, xtag)
+	} else if ext == SelfExt {
+		d.d.decodeValue(baseRV(rv), d.h.fnNoExt(basetype))
+	} else {
+		d.d.interfaceExtConvertAndDecode(rv, ext)
+	}
+	d.bdRead = false
+}
+
+func (d *cborDecDriver) DecodeNaked() {
+	if !d.bdRead {
+		d.readNextBd()
+	}
+
+	n := d.d.naked()
+	var decodeFurther bool
+
+	switch d.bd >> 5 {
+	case cborMajorUint:
+		if d.h.SignedInteger {
+			n.v = valueTypeInt
+			n.i = d.DecodeInt64()
+		} else {
+			n.v = valueTypeUint
+			n.u = d.DecodeUint64()
+		}
+	case cborMajorNegInt:
+		n.v = valueTypeInt
+		n.i = d.DecodeInt64()
+	case cborMajorBytes:
+		d.d.fauxUnionReadRawBytes(false)
+	case cborMajorString:
+		n.v = valueTypeString
+		n.s = d.d.stringZC(d.DecodeStringAsBytes())
+	case cborMajorArray:
+		n.v = valueTypeArray
+		decodeFurther = true
+	case cborMajorMap:
+		n.v = valueTypeMap
+		decodeFurther = true
+	case cborMajorTag:
+		n.v = valueTypeExt
+		n.u = d.decUint()
+		n.l = nil
+		if n.u == 0 || n.u == 1 {
+			d.bdRead = false
+			n.v = valueTypeTime
+			n.t = d.decodeTime(n.u)
+		} else if d.st && d.h.getExtForTag(n.u) == nil {
+			// d.skipTags() // no need to call this - tags already skipped
+			d.bdRead = false
+			d.DecodeNaked()
+			return // return when done (as true recursive function)
+		}
+	case cborMajorSimpleOrFloat:
+		switch d.bd {
+		case cborBdNil, cborBdUndefined:
+			n.v = valueTypeNil
+		case cborBdFalse:
+			n.v = valueTypeBool
+			n.b = false
+		case cborBdTrue:
+			n.v = valueTypeBool
+			n.b = true
+		case cborBdFloat16, cborBdFloat32, cborBdFloat64:
+			n.v = valueTypeFloat
+			n.f = d.DecodeFloat64()
+		default:
+			d.d.errorf("decodeNaked: Unrecognized d.bd: 0x%x", d.bd)
+		}
+	default: // should never happen
+		d.d.errorf("decodeNaked: Unrecognized d.bd: 0x%x", d.bd)
+	}
+	if !decodeFurther {
+		d.bdRead = false
+	}
+}
+
+func (d *cborDecDriver) uintBytes() (v []byte, ui uint64) {
+	// this is only used by nextValueBytes, so it's ok to
+	// use readx and bigenstd here.
+	switch vv := d.bd & 0x1f; vv {
+	case 0x18:
+		v = d.d.decRd.readx(1)
+		ui = uint64(v[0])
+	case 0x19:
+		v = d.d.decRd.readx(2)
+		ui = uint64(bigenstd.Uint16(v))
+	case 0x1a:
+		v = d.d.decRd.readx(4)
+		ui = uint64(bigenstd.Uint32(v))
+	case 0x1b:
+		v = d.d.decRd.readx(8)
+		ui = uint64(bigenstd.Uint64(v))
+	default:
+		if vv > 0x1b {
+			d.d.errorf("invalid descriptor decoding uint: %x/%s", d.bd, cbordesc(d.bd))
+		}
+		ui = uint64(vv)
+	}
+	return
+}
+
+func (d *cborDecDriver) nextValueBytes(v0 []byte) (v []byte) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
+	v = v0
+	var h = decNextValueBytesHelper{d: &d.d}
+	var cursor = d.d.rb.c - 1
+	h.append1(&v, d.bd)
+	v = d.nextValueBytesBdReadR(v)
+	d.bdRead = false
+	h.bytesRdV(&v, cursor)
+	return
+}
+
+func (d *cborDecDriver) nextValueBytesR(v0 []byte) (v []byte) {
+	d.readNextBd()
+	v = v0
+	var h = decNextValueBytesHelper{d: &d.d}
+	h.append1(&v, d.bd)
+	return d.nextValueBytesBdReadR(v)
+}
+
+func (d *cborDecDriver) nextValueBytesBdReadR(v0 []byte) (v []byte) {
+	v = v0
+	var h = decNextValueBytesHelper{d: &d.d}
+
+	var bs []byte
+	var ui uint64
+
+	switch d.bd >> 5 {
+	case cborMajorUint, cborMajorNegInt:
+		bs, _ = d.uintBytes()
+		h.appendN(&v, bs...)
+	case cborMajorString, cborMajorBytes:
+		if d.bd == cborBdIndefiniteBytes || d.bd == cborBdIndefiniteString {
+			for {
+				d.readNextBd()
+				h.append1(&v, d.bd)
+				if d.bd == cborBdBreak {
+					break
+				}
+				bs, ui = d.uintBytes()
+				h.appendN(&v, bs...)
+				h.appendN(&v, d.d.decRd.readx(uint(ui))...)
+			}
+		} else {
+			bs, ui = d.uintBytes()
+			h.appendN(&v, bs...)
+			h.appendN(&v, d.d.decRd.readx(uint(ui))...)
+		}
+	case cborMajorArray:
+		if d.bd == cborBdIndefiniteArray {
+			for {
+				d.readNextBd()
+				h.append1(&v, d.bd)
+				if d.bd == cborBdBreak {
+					break
+				}
+				v = d.nextValueBytesBdReadR(v)
+			}
+		} else {
+			bs, ui = d.uintBytes()
+			h.appendN(&v, bs...)
+			for i := uint64(0); i < ui; i++ {
+				v = d.nextValueBytesR(v)
+			}
+		}
+	case cborMajorMap:
+		if d.bd == cborBdIndefiniteMap {
+			for {
+				d.readNextBd()
+				h.append1(&v, d.bd)
+				if d.bd == cborBdBreak {
+					break
+				}
+				v = d.nextValueBytesBdReadR(v)
+				v = d.nextValueBytesR(v)
+			}
+		} else {
+			bs, ui = d.uintBytes()
+			h.appendN(&v, bs...)
+			for i := uint64(0); i < ui; i++ {
+				v = d.nextValueBytesR(v)
+				v = d.nextValueBytesR(v)
+			}
+		}
+	case cborMajorTag:
+		bs, _ = d.uintBytes()
+		h.appendN(&v, bs...)
+		v = d.nextValueBytesR(v)
+	case cborMajorSimpleOrFloat:
+		switch d.bd {
+		case cborBdNil, cborBdUndefined, cborBdFalse, cborBdTrue: // pass
+		case cborBdFloat16:
+			h.appendN(&v, d.d.decRd.readx(2)...)
+		case cborBdFloat32:
+			h.appendN(&v, d.d.decRd.readx(4)...)
+		case cborBdFloat64:
+			h.appendN(&v, d.d.decRd.readx(8)...)
+		default:
+			d.d.errorf("nextValueBytes: Unrecognized d.bd: 0x%x", d.bd)
+		}
+	default: // should never happen
+		d.d.errorf("nextValueBytes: Unrecognized d.bd: 0x%x", d.bd)
+	}
+	return
+}
+
+// -------------------------
+
+// CborHandle is a Handle for the CBOR encoding format,
+// defined at http://tools.ietf.org/html/rfc7049 and documented further at http://cbor.io .
+//
+// CBOR is comprehensively supported, including support for:
+//   - indefinite-length arrays/maps/bytes/strings
+//   - (extension) tags in range 0..0xffff (0 .. 65535)
+//   - half, single and double-precision floats
+//   - all numbers (1, 2, 4 and 8-byte signed and unsigned integers)
+//   - nil, true, false, ...
+//   - arrays and maps, bytes and text strings
+//
+// None of the optional extensions (with tags) defined in the spec are supported out-of-the-box.
+// Users can implement them as needed (using SetExt), including spec-documented ones:
+//   - timestamp, BigNum, BigFloat, Decimals,
+//   - Encoded Text (e.g. URL, regexp, base64, MIME Message), etc.
+type CborHandle struct {
+	binaryEncodingType
+	// noElemSeparators
+	BasicHandle
+
+	// IndefiniteLength=true, means that we encode using indefinitelength
+	IndefiniteLength bool
+
+	// TimeRFC3339 says to encode time.Time using RFC3339 format.
+	// If unset, we encode time.Time using seconds past epoch.
+	TimeRFC3339 bool
+
+	// SkipUnexpectedTags says to skip over any tags for which extensions are
+	// not defined. This is in keeping with the cbor spec on "Optional Tagging of Items".
+	//
+	// Furthermore, this allows the skipping over of the Self Describing Tag 0xd9d9f7.
+	SkipUnexpectedTags bool
+}
+
+// Name returns the name of the handle: cbor
+func (h *CborHandle) Name() string { return "cbor" }
+
+func (h *CborHandle) desc(bd byte) string { return cbordesc(bd) }
+
+func (h *CborHandle) newEncDriver() encDriver {
+	var e = &cborEncDriver{h: h}
+	e.e.e = e
+	e.e.init(h)
+	e.reset()
+	return e
+}
+
+func (h *CborHandle) newDecDriver() decDriver {
+	d := &cborDecDriver{h: h, st: h.SkipUnexpectedTags}
+	d.d.d = d
+	d.d.cbor = true
+	d.d.init(h)
+	d.reset()
+	return d
+}
+
+func (d *cborDecDriver) reset() {
+	d.bdAndBdread.reset()
+	d.st = d.h.SkipUnexpectedTags
+}
+
+var _ decDriver = (*cborDecDriver)(nil)
+var _ encDriver = (*cborEncDriver)(nil)

vendor/github.com/ugorji/go/codec/codecgen.go

@@ -0,0 +1,17 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build codecgen || generated
+// +build codecgen generated
+
+package codec
+
+// this file sets the codecgen variable to true
+// when the build tag codecgen is set.
+//
+// some tests depend on knowing whether in the context of codecgen or not.
+// For example, some tests should be skipped during codecgen e.g. missing fields tests.
+
+func init() {
+	codecgen = true
+}

vendor/github.com/ugorji/go/codec/decimal.go

@@ -0,0 +1,491 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+package codec
+
+import (
+	"math"
+	"strconv"
+)
+
+// Per go spec, floats are represented in memory as
+// IEEE single or double precision floating point values.
+//
+// We also looked at the source for stdlib math/modf.go,
+// reviewed https://github.com/chewxy/math32
+// and read wikipedia documents describing the formats.
+//
+// It became clear that we could easily look at the bits to determine
+// whether any fraction exists.
+
+func parseFloat32(b []byte) (f float32, err error) {
+	return parseFloat32_custom(b)
+}
+
+func parseFloat64(b []byte) (f float64, err error) {
+	return parseFloat64_custom(b)
+}
+
+func parseFloat32_strconv(b []byte) (f float32, err error) {
+	f64, err := strconv.ParseFloat(stringView(b), 32)
+	f = float32(f64)
+	return
+}
+
+func parseFloat64_strconv(b []byte) (f float64, err error) {
+	return strconv.ParseFloat(stringView(b), 64)
+}
+
+// ------ parseFloat custom below --------
+
+// JSON really supports decimal numbers in base 10 notation, with exponent support.
+//
+// We assume the following:
+//   - a lot of floating point numbers in json files will have defined precision
+//     (in terms of number of digits after decimal point), etc.
+//   - these (referenced above) can be written in exact format.
+//
+// strconv.ParseFloat has some unnecessary overhead which we can do without
+// for the common case:
+//
+//    - expensive char-by-char check to see if underscores are in right place
+//    - testing for and skipping underscores
+//    - check if the string matches ignorecase +/- inf, +/- infinity, nan
+//    - support for base 16 (0xFFFF...)
+//
+// The functions below will try a fast-path for floats which can be decoded
+// without any loss of precision, meaning they:
+//
+//    - fits within the significand bits of the 32-bits or 64-bits
+//    - exponent fits within the exponent value
+//    - there is no truncation (any extra numbers are all trailing zeros)
+//
+// To figure out what the values are for maxMantDigits, use this idea below:
+//
+// 2^23 =                 838 8608 (between 10^ 6 and 10^ 7) (significand bits of uint32)
+// 2^32 =             42 9496 7296 (between 10^ 9 and 10^10) (full uint32)
+// 2^52 =      4503 5996 2737 0496 (between 10^15 and 10^16) (significand bits of uint64)
+// 2^64 = 1844 6744 0737 0955 1616 (between 10^19 and 10^20) (full uint64)
+//
+// Note: we only allow for up to what can comfortably fit into the significand
+// ignoring the exponent, and we only try to parse iff significand fits.
+
+const (
+	fMaxMultiplierForExactPow10_64 = 1e15
+	fMaxMultiplierForExactPow10_32 = 1e7
+
+	fUint64Cutoff = (1<<64-1)/10 + 1
+	// fUint32Cutoff = (1<<32-1)/10 + 1
+
+	fBase = 10
+)
+
+const (
+	thousand    = 1000
+	million     = thousand * thousand
+	billion     = thousand * million
+	trillion    = thousand * billion
+	quadrillion = thousand * trillion
+	quintillion = thousand * quadrillion
+)
+
+// Exact powers of 10.
+var uint64pow10 = [...]uint64{
+	1, 10, 100,
+	1 * thousand, 10 * thousand, 100 * thousand,
+	1 * million, 10 * million, 100 * million,
+	1 * billion, 10 * billion, 100 * billion,
+	1 * trillion, 10 * trillion, 100 * trillion,
+	1 * quadrillion, 10 * quadrillion, 100 * quadrillion,
+	1 * quintillion, 10 * quintillion,
+}
+var float64pow10 = [...]float64{
+	1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
+	1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
+	1e20, 1e21, 1e22,
+}
+var float32pow10 = [...]float32{
+	1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10,
+}
+
+type floatinfo struct {
+	mantbits uint8
+
+	// expbits uint8 // (unused)
+	// bias    int16 // (unused)
+	// is32bit bool // (unused)
+
+	exactPow10 int8 // Exact powers of ten are <= 10^N (32: 10, 64: 22)
+
+	exactInts int8 // Exact integers are <= 10^N (for non-float, set to 0)
+
+	// maxMantDigits int8 // 10^19 fits in uint64, while 10^9 fits in uint32
+
+	mantCutoffIsUint64Cutoff bool
+
+	mantCutoff uint64
+}
+
+var fi32 = floatinfo{23, 10, 7, false, 1<<23 - 1}
+var fi64 = floatinfo{52, 22, 15, false, 1<<52 - 1}
+
+var fi64u = floatinfo{0, 19, 0, true, fUint64Cutoff}
+
+func noFrac64(fbits uint64) bool {
+	exp := uint64(fbits>>52)&0x7FF - 1023 // uint(x>>shift)&mask - bias
+	// clear top 12+e bits, the integer part; if the rest is 0, then no fraction.
+	return exp < 52 && fbits<<(12+exp) == 0 // means there's no fractional part
+}
+
+func noFrac32(fbits uint32) bool {
+	exp := uint32(fbits>>23)&0xFF - 127 // uint(x>>shift)&mask - bias
+	// clear top 9+e bits, the integer part; if the rest is 0, then no fraction.
+	return exp < 23 && fbits<<(9+exp) == 0 // means there's no fractional part
+}
+
+func strconvParseErr(b []byte, fn string) error {
+	return &strconv.NumError{
+		Func: fn,
+		Err:  strconv.ErrSyntax,
+		Num:  string(b),
+	}
+}
+
+func parseFloat32_reader(r readFloatResult) (f float32, fail bool) {
+	f = float32(r.mantissa)
+	if r.exp == 0 {
+	} else if r.exp < 0 { // int / 10^k
+		f /= float32pow10[uint8(-r.exp)]
+	} else { // exp > 0
+		if r.exp > fi32.exactPow10 {
+			f *= float32pow10[r.exp-fi32.exactPow10]
+			if f > fMaxMultiplierForExactPow10_32 { // exponent too large - outside range
+				fail = true
+				return // ok = false
+			}
+			f *= float32pow10[fi32.exactPow10]
+		} else {
+			f *= float32pow10[uint8(r.exp)]
+		}
+	}
+	if r.neg {
+		f = -f
+	}
+	return
+}
+
+func parseFloat32_custom(b []byte) (f float32, err error) {
+	r := readFloat(b, fi32)
+	if r.bad {
+		return 0, strconvParseErr(b, "ParseFloat")
+	}
+	if r.ok {
+		f, r.bad = parseFloat32_reader(r)
+		if !r.bad {
+			return
+		}
+	}
+	return parseFloat32_strconv(b)
+}
+
+func parseFloat64_reader(r readFloatResult) (f float64, fail bool) {
+	f = float64(r.mantissa)
+	if r.exp == 0 {
+	} else if r.exp < 0 { // int / 10^k
+		f /= float64pow10[-uint8(r.exp)]
+	} else { // exp > 0
+		if r.exp > fi64.exactPow10 {
+			f *= float64pow10[r.exp-fi64.exactPow10]
+			if f > fMaxMultiplierForExactPow10_64 { // exponent too large - outside range
+				fail = true
+				return
+			}
+			f *= float64pow10[fi64.exactPow10]
+		} else {
+			f *= float64pow10[uint8(r.exp)]
+		}
+	}
+	if r.neg {
+		f = -f
+	}
+	return
+}
+
+func parseFloat64_custom(b []byte) (f float64, err error) {
+	r := readFloat(b, fi64)
+	if r.bad {
+		return 0, strconvParseErr(b, "ParseFloat")
+	}
+	if r.ok {
+		f, r.bad = parseFloat64_reader(r)
+		if !r.bad {
+			return
+		}
+	}
+	return parseFloat64_strconv(b)
+}
+
+func parseUint64_simple(b []byte) (n uint64, ok bool) {
+	var i int
+	var n1 uint64
+	var c uint8
+LOOP:
+	if i < len(b) {
+		c = b[i]
+		// unsigned integers don't overflow well on multiplication, so check cutoff here
+		// e.g. (maxUint64-5)*10 doesn't overflow well ...
+		// if n >= fUint64Cutoff || !isDigitChar(b[i]) { // if c < '0' || c > '9' {
+		if n >= fUint64Cutoff || c < '0' || c > '9' {
+			return
+		} else if c == '0' {
+			n *= fBase
+		} else {
+			n1 = n
+			n = n*fBase + uint64(c-'0')
+			if n < n1 {
+				return
+			}
+		}
+		i++
+		goto LOOP
+	}
+	ok = true
+	return
+}
+
+func parseUint64_reader(r readFloatResult) (f uint64, fail bool) {
+	f = r.mantissa
+	if r.exp == 0 {
+	} else if r.exp < 0 { // int / 10^k
+		if f%uint64pow10[uint8(-r.exp)] != 0 {
+			fail = true
+		} else {
+			f /= uint64pow10[uint8(-r.exp)]
+		}
+	} else { // exp > 0
+		f *= uint64pow10[uint8(r.exp)]
+	}
+	return
+}
+
+func parseInteger_bytes(b []byte) (u uint64, neg, ok bool) {
+	if len(b) == 0 {
+		ok = true
+		return
+	}
+	if b[0] == '-' {
+		if len(b) == 1 {
+			return
+		}
+		neg = true
+		b = b[1:]
+	}
+
+	u, ok = parseUint64_simple(b)
+	if ok {
+		return
+	}
+
+	r := readFloat(b, fi64u)
+	if r.ok {
+		var fail bool
+		u, fail = parseUint64_reader(r)
+		if fail {
+			f, err := parseFloat64(b)
+			if err != nil {
+				return
+			}
+			if !noFrac64(math.Float64bits(f)) {
+				return
+			}
+			u = uint64(f)
+		}
+		ok = true
+		return
+	}
+	return
+}
+
+// parseNumber will return an integer if only composed of [-]?[0-9]+
+// Else it will return a float.
+func parseNumber(b []byte, z *fauxUnion, preferSignedInt bool) (err error) {
+	var ok, neg bool
+	var f uint64
+
+	if len(b) == 0 {
+		return
+	}
+
+	if b[0] == '-' {
+		neg = true
+		f, ok = parseUint64_simple(b[1:])
+	} else {
+		f, ok = parseUint64_simple(b)
+	}
+
+	if ok {
+		if neg {
+			z.v = valueTypeInt
+			if chkOvf.Uint2Int(f, neg) {
+				return strconvParseErr(b, "ParseInt")
+			}
+			z.i = -int64(f)
+		} else if preferSignedInt {
+			z.v = valueTypeInt
+			if chkOvf.Uint2Int(f, neg) {
+				return strconvParseErr(b, "ParseInt")
+			}
+			z.i = int64(f)
+		} else {
+			z.v = valueTypeUint
+			z.u = f
+		}
+		return
+	}
+
+	z.v = valueTypeFloat
+	z.f, err = parseFloat64_custom(b)
+	return
+}
+
+type readFloatResult struct {
+	mantissa uint64
+	exp      int8
+	neg      bool
+	trunc    bool
+	bad      bool // bad decimal string
+	hardexp  bool // exponent is hard to handle (> 2 digits, etc)
+	ok       bool
+	// sawdot   bool
+	// sawexp   bool
+	//_ [2]bool // padding
+}
+
+func readFloat(s []byte, y floatinfo) (r readFloatResult) {
+	var i uint // uint, so that we eliminate bounds checking
+	var slen = uint(len(s))
+	if slen == 0 {
+		// read an empty string as the zero value
+		// r.bad = true
+		r.ok = true
+		return
+	}
+
+	if s[0] == '-' {
+		r.neg = true
+		i++
+	}
+
+	// we considered punting early if string has length > maxMantDigits, but this doesn't account
+	// for trailing 0's e.g. 700000000000000000000 can be encoded exactly as it is 7e20
+
+	var nd, ndMant, dp int8
+	var sawdot, sawexp bool
+	var xu uint64
+
+LOOP:
+	for ; i < slen; i++ {
+		switch s[i] {
+		case '.':
+			if sawdot {
+				r.bad = true
+				return
+			}
+			sawdot = true
+			dp = nd
+		case 'e', 'E':
+			sawexp = true
+			break LOOP
+		case '0':
+			if nd == 0 {
+				dp--
+				continue LOOP
+			}
+			nd++
+			if r.mantissa < y.mantCutoff {
+				r.mantissa *= fBase
+				ndMant++
+			}
+		case '1', '2', '3', '4', '5', '6', '7', '8', '9':
+			nd++
+			if y.mantCutoffIsUint64Cutoff && r.mantissa < fUint64Cutoff {
+				r.mantissa *= fBase
+				xu = r.mantissa + uint64(s[i]-'0')
+				if xu < r.mantissa {
+					r.trunc = true
+					return
+				}
+				r.mantissa = xu
+			} else if r.mantissa < y.mantCutoff {
+				// mantissa = (mantissa << 1) + (mantissa << 3) + uint64(c-'0')
+				r.mantissa = r.mantissa*fBase + uint64(s[i]-'0')
+			} else {
+				r.trunc = true
+				return
+			}
+			ndMant++
+		default:
+			r.bad = true
+			return
+		}
+	}
+
+	if !sawdot {
+		dp = nd
+	}
+
+	if sawexp {
+		i++
+		if i < slen {
+			var eneg bool
+			if s[i] == '+' {
+				i++
+			} else if s[i] == '-' {
+				i++
+				eneg = true
+			}
+			if i < slen {
+				// for exact match, exponent is 1 or 2 digits (float64: -22 to 37, float32: -1 to 17).
+				// exit quick if exponent is more than 2 digits.
+				if i+2 < slen {
+					r.hardexp = true
+					return
+				}
+				var e int8
+				if s[i] < '0' || s[i] > '9' { // !isDigitChar(s[i]) { //
+					r.bad = true
+					return
+				}
+				e = int8(s[i] - '0')
+				i++
+				if i < slen {
+					if s[i] < '0' || s[i] > '9' { // !isDigitChar(s[i]) { //
+						r.bad = true
+						return
+					}
+					e = e*fBase + int8(s[i]-'0') // (e << 1) + (e << 3) + int8(s[i]-'0')
+					i++
+				}
+				if eneg {
+					dp -= e
+				} else {
+					dp += e
+				}
+			}
+		}
+	}
+
+	if r.mantissa != 0 {
+		r.exp = dp - ndMant
+		// do not set ok=true for cases we cannot handle
+		if r.exp < -y.exactPow10 ||
+			r.exp > y.exactInts+y.exactPow10 ||
+			(y.mantbits != 0 && r.mantissa>>y.mantbits != 0) {
+			r.hardexp = true
+			return
+		}
+	}
+
+	r.ok = true
+	return
+}

vendor/github.com/ugorji/go/codec/doc.go

@@ -0,0 +1,228 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+/*
+Package codec provides a
+High Performance, Feature-Rich Idiomatic Go 1.4+ codec/encoding library
+for binc, msgpack, cbor, json.
+
+Supported Serialization formats are:
+
+  - msgpack: https://github.com/msgpack/msgpack
+  - binc:    http://github.com/ugorji/binc
+  - cbor:    http://cbor.io http://tools.ietf.org/html/rfc7049
+  - json:    http://json.org http://tools.ietf.org/html/rfc7159
+  - simple:
+
+This package will carefully use 'package unsafe' for performance reasons in specific places.
+You can build without unsafe use by passing the safe or appengine tag
+i.e. 'go install -tags=codec.safe ...'.
+
+This library works with both the standard `gc` and the `gccgo` compilers.
+
+For detailed usage information, read the primer at http://ugorji.net/blog/go-codec-primer .
+
+The idiomatic Go support is as seen in other encoding packages in
+the standard library (ie json, xml, gob, etc).
+
+Rich Feature Set includes:
+
+  - Simple but extremely powerful and feature-rich API
+  - Support for go 1.4 and above, while selectively using newer APIs for later releases
+  - Excellent code coverage ( > 90% )
+  - Very High Performance.
+    Our extensive benchmarks show us outperforming Gob, Json, Bson, etc by 2-4X.
+  - Careful selected use of 'unsafe' for targeted performance gains.
+  - 100% safe mode supported, where 'unsafe' is not used at all.
+  - Lock-free (sans mutex) concurrency for scaling to 100's of cores
+  - In-place updates during decode, with option to zero value in maps and slices prior to decode
+  - Coerce types where appropriate
+    e.g. decode an int in the stream into a float, decode numbers from formatted strings, etc
+  - Corner Cases:
+    Overflows, nil maps/slices, nil values in streams are handled correctly
+  - Standard field renaming via tags
+  - Support for omitting empty fields during an encoding
+  - Encoding from any value and decoding into pointer to any value
+    (struct, slice, map, primitives, pointers, interface{}, etc)
+  - Extensions to support efficient encoding/decoding of any named types
+  - Support encoding.(Binary|Text)(M|Unm)arshaler interfaces
+  - Support using existence of `IsZero() bool` to determine if a value is a zero value.
+    Analogous to time.Time.IsZero() bool.
+  - Decoding without a schema (into a interface{}).
+    Includes Options to configure what specific map or slice type to use
+    when decoding an encoded list or map into a nil interface{}
+  - Mapping a non-interface type to an interface, so we can decode appropriately
+    into any interface type with a correctly configured non-interface value.
+  - Encode a struct as an array, and decode struct from an array in the data stream
+  - Option to encode struct keys as numbers (instead of strings)
+    (to support structured streams with fields encoded as numeric codes)
+  - Comprehensive support for anonymous fields
+  - Fast (no-reflection) encoding/decoding of common maps and slices
+  - Code-generation for faster performance, supported in go 1.6+
+  - Support binary (e.g. messagepack, cbor) and text (e.g. json) formats
+  - Support indefinite-length formats to enable true streaming
+    (for formats which support it e.g. json, cbor)
+  - Support canonical encoding, where a value is ALWAYS encoded as same sequence of bytes.
+    This mostly applies to maps, where iteration order is non-deterministic.
+  - NIL in data stream decoded as zero value
+  - Never silently skip data when decoding.
+    User decides whether to return an error or silently skip data when keys or indexes
+    in the data stream do not map to fields in the struct.
+  - Detect and error when encoding a cyclic reference (instead of stack overflow shutdown)
+  - Encode/Decode from/to chan types (for iterative streaming support)
+  - Drop-in replacement for encoding/json. `json:` key in struct tag supported.
+  - Provides a RPC Server and Client Codec for net/rpc communication protocol.
+  - Handle unique idiosyncrasies of codecs e.g.
+    - For messagepack, configure how ambiguities in handling raw bytes are resolved
+    - For messagepack, provide rpc server/client codec to support
+      msgpack-rpc protocol defined at:
+      https://github.com/msgpack-rpc/msgpack-rpc/blob/master/spec.md
+
+Extension Support
+
+Users can register a function to handle the encoding or decoding of
+their custom types.
+
+There are no restrictions on what the custom type can be. Some examples:
+
+    type BisSet   []int
+    type BitSet64 uint64
+    type UUID     string
+    type MyStructWithUnexportedFields struct { a int; b bool; c []int; }
+    type GifImage struct { ... }
+
+As an illustration, MyStructWithUnexportedFields would normally be
+encoded as an empty map because it has no exported fields, while UUID
+would be encoded as a string. However, with extension support, you can
+encode any of these however you like.
+
+There is also seamless support provided for registering an extension (with a tag)
+but letting the encoding mechanism default to the standard way.
+
+Custom Encoding and Decoding
+
+This package maintains symmetry in the encoding and decoding halfs.
+We determine how to encode or decode by walking this decision tree
+
+  - is there an extension registered for the type?
+  - is type a codec.Selfer?
+  - is format binary, and is type a encoding.BinaryMarshaler and BinaryUnmarshaler?
+  - is format specifically json, and is type a encoding/json.Marshaler and Unmarshaler?
+  - is format text-based, and type an encoding.TextMarshaler and TextUnmarshaler?
+  - else we use a pair of functions based on the "kind" of the type e.g. map, slice, int64, etc
+
+This symmetry is important to reduce chances of issues happening because the
+encoding and decoding sides are out of sync e.g. decoded via very specific
+encoding.TextUnmarshaler but encoded via kind-specific generalized mode.
+
+Consequently, if a type only defines one-half of the symmetry
+(e.g. it implements UnmarshalJSON() but not MarshalJSON() ),
+then that type doesn't satisfy the check and we will continue walking down the
+decision tree.
+
+RPC
+
+RPC Client and Server Codecs are implemented, so the codecs can be used
+with the standard net/rpc package.
+
+Usage
+
+The Handle is SAFE for concurrent READ, but NOT SAFE for concurrent modification.
+
+The Encoder and Decoder are NOT safe for concurrent use.
+
+Consequently, the usage model is basically:
+
+    - Create and initialize the Handle before any use.
+      Once created, DO NOT modify it.
+    - Multiple Encoders or Decoders can now use the Handle concurrently.
+      They only read information off the Handle (never write).
+    - However, each Encoder or Decoder MUST not be used concurrently
+    - To re-use an Encoder/Decoder, call Reset(...) on it first.
+      This allows you use state maintained on the Encoder/Decoder.
+
+Sample usage model:
+
+    // create and configure Handle
+    var (
+      bh codec.BincHandle
+      mh codec.MsgpackHandle
+      ch codec.CborHandle
+    )
+
+    mh.MapType = reflect.TypeOf(map[string]interface{}(nil))
+
+    // configure extensions
+    // e.g. for msgpack, define functions and enable Time support for tag 1
+    // mh.SetExt(reflect.TypeOf(time.Time{}), 1, myExt)
+
+    // create and use decoder/encoder
+    var (
+      r io.Reader
+      w io.Writer
+      b []byte
+      h = &bh // or mh to use msgpack
+    )
+
+    dec = codec.NewDecoder(r, h)
+    dec = codec.NewDecoderBytes(b, h)
+    err = dec.Decode(&v)
+
+    enc = codec.NewEncoder(w, h)
+    enc = codec.NewEncoderBytes(&b, h)
+    err = enc.Encode(v)
+
+    //RPC Server
+    go func() {
+        for {
+            conn, err := listener.Accept()
+            rpcCodec := codec.GoRpc.ServerCodec(conn, h)
+            //OR rpcCodec := codec.MsgpackSpecRpc.ServerCodec(conn, h)
+            rpc.ServeCodec(rpcCodec)
+        }
+    }()
+
+    //RPC Communication (client side)
+    conn, err = net.Dial("tcp", "localhost:5555")
+    rpcCodec := codec.GoRpc.ClientCodec(conn, h)
+    //OR rpcCodec := codec.MsgpackSpecRpc.ClientCodec(conn, h)
+    client := rpc.NewClientWithCodec(rpcCodec)
+
+Running Tests
+
+To run tests, use the following:
+
+    go test
+
+To run the full suite of tests, use the following:
+
+    go test -tags alltests -run Suite
+
+You can run the tag 'codec.safe' to run tests or build in safe mode. e.g.
+
+    go test -tags codec.safe -run Json
+    go test -tags "alltests codec.safe" -run Suite
+
+Running Benchmarks
+
+    cd bench
+    go test -bench . -benchmem -benchtime 1s
+
+Please see http://github.com/ugorji/go-codec-bench .
+
+Caveats
+
+Struct fields matching the following are ignored during encoding and decoding
+    - struct tag value set to -
+    - func, complex numbers, unsafe pointers
+    - unexported and not embedded
+    - unexported and embedded and not struct kind
+    - unexported and embedded pointers (from go1.10)
+
+Every other field in a struct will be encoded/decoded.
+
+Embedded fields are encoded as if they exist in the top-level struct,
+with some caveats. See Encode documentation.
+
+*/
+package codec

vendor/github.com/ugorji/go/codec/fast-path.go.tmpl

@@ -0,0 +1,555 @@
+// +build !notfastpath
+// +build !codec.notfastpath
+
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+// Code generated from fast-path.go.tmpl - DO NOT EDIT.
+
+package codec
+
+// Fast path functions try to create a fast path encode or decode implementation
+// for common maps and slices.
+//
+// We define the functions and register them in this single file
+// so as not to pollute the encode.go and decode.go, and create a dependency in there.
+// This file can be omitted without causing a build failure.
+//
+// The advantage of fast paths is:
+//	  - Many calls bypass reflection altogether
+// 
+// Currently support
+//	  - slice of all builtin types (numeric, bool, string, []byte)
+//    - maps of builtin types to builtin or interface{} type, EXCEPT FOR
+//      keys of type uintptr, int8/16/32, uint16/32, float32/64, bool, interface{}
+//      AND values of type type int8/16/32, uint16/32
+// This should provide adequate "typical" implementations.
+// 
+// Note that fast track decode functions must handle values for which an address cannot be obtained.
+// For example: 
+//	 m2 := map[string]int{}
+//	 p2 := []interface{}{m2}
+//	 // decoding into p2 will bomb if fast track functions do not treat like unaddressable.
+// 
+
+{{/*
+fastpathEncMapStringUint64R  (called by fastpath...switch)
+EncMapStringUint64V (called by codecgen)
+
+fastpathEncSliceBoolR: (called by fastpath...switch) (checks f.ti.mbs and calls one of them below)
+EncSliceBoolV  (also called by codecgen)
+EncAsMapSliceBoolV (delegate when mapbyslice=true)
+
+fastpathDecSliceIntfR (called by fastpath...switch) (calls Y or N below depending on if it can be updated)
+DecSliceIntfX  (called by codecgen) (calls Y below)
+DecSliceIntfY  (delegate when slice CAN be updated)
+DecSliceIntfN  (delegate when slice CANNOT be updated e.g. from array or non-addressable slice)
+
+fastpathDecMap...R (called by fastpath...switch) (calls L or X? below)
+DecMap...X  (called by codecgen)
+DecMap...L  (delegated to by both above)
+*/ -}}
+
+import (
+	"reflect"
+	"sort"
+)
+
+const fastpathEnabled = true
+
+{{/*
+const fastpathMapBySliceErrMsg = "mapBySlice requires even slice length, but got %v"
+*/ -}}
+
+type fastpathT struct {}
+
+var fastpathTV fastpathT
+
+type fastpathE struct {
+	{{/* rtid uintptr */ -}}
+	rt reflect.Type 
+	encfn func(*Encoder, *codecFnInfo, reflect.Value)
+	decfn func(*Decoder, *codecFnInfo, reflect.Value)
+}
+
+type fastpathA [{{ .FastpathLen }}]fastpathE
+type fastpathARtid [{{ .FastpathLen }}]uintptr
+
+var fastpathAv fastpathA
+var fastpathAvRtid fastpathARtid
+
+type fastpathAslice struct{}
+
+func (fastpathAslice) Len() int { return {{ .FastpathLen }} }
+func (fastpathAslice) Less(i, j int) bool {
+	return fastpathAvRtid[uint(i)] < fastpathAvRtid[uint(j)]
+}
+func (fastpathAslice) Swap(i, j int) {
+	fastpathAvRtid[uint(i)], fastpathAvRtid[uint(j)] = fastpathAvRtid[uint(j)], fastpathAvRtid[uint(i)]
+	fastpathAv[uint(i)], fastpathAv[uint(j)] = fastpathAv[uint(j)], fastpathAv[uint(i)]
+}
+
+func fastpathAvIndex(rtid uintptr) int {
+	// use binary search to grab the index (adapted from sort/search.go)
+	// Note: we use goto (instead of for loop) so this can be inlined.
+ 	// h, i, j := 0, 0, {{ .FastpathLen }}
+	var h, i uint
+	var j uint = {{ .FastpathLen }}
+LOOP:
+	if i < j {
+		h = (i + j) >> 1 // avoid overflow when computing h // h = i + (j-i)/2
+		if fastpathAvRtid[h] < rtid {
+			i = h + 1
+		} else {
+			j = h
+		}
+		goto LOOP
+	}
+	if i < {{ .FastpathLen }} && fastpathAvRtid[i] == rtid {
+		return int(i)
+	}
+	return -1
+}
+
+
+// due to possible initialization loop error, make fastpath in an init()
+func init() {
+	var i uint = 0
+	fn := func(v interface{},
+		fe func(*Encoder, *codecFnInfo, reflect.Value),
+		fd func(*Decoder, *codecFnInfo, reflect.Value)) {
+		xrt := reflect.TypeOf(v)
+		xptr := rt2id(xrt)
+        fastpathAvRtid[i] = xptr
+		fastpathAv[i] = fastpathE{xrt, fe, fd}
+		i++
+	}
+	{{/* do not register []byte in fast-path */}}
+	{{range .Values}}{{if not .Primitive}}{{if not .MapKey -}}
+	fn([]{{ .Elem }}(nil), (*Encoder).{{ .MethodNamePfx "fastpathEnc" false }}R, (*Decoder).{{ .MethodNamePfx "fastpathDec" false }}R)
+	{{end}}{{end}}{{end}}
+	
+	{{range .Values}}{{if not .Primitive}}{{if .MapKey -}}
+	fn(map[{{ .MapKey }}]{{ .Elem }}(nil), (*Encoder).{{ .MethodNamePfx "fastpathEnc" false }}R, (*Decoder).{{ .MethodNamePfx "fastpathDec" false }}R)
+	{{end}}{{end}}{{end}}
+	
+	sort.Sort(fastpathAslice{})
+}
+
+// -- encode
+
+// -- -- fast path type switch
+func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool {
+	switch v := iv.(type) {
+{{range .Values}}{{if not .Primitive}}{{if not .MapKey -}}
+	case []{{ .Elem }}:
+		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(v, e)
+	case *[]{{ .Elem }}:
+		if *v == nil {
+			e.e.EncodeNil()
+		} else {
+			fastpathTV.{{ .MethodNamePfx "Enc" false }}V(*v, e)
+		}
+{{end}}{{end}}{{end -}}
+
+{{range .Values}}{{if not .Primitive}}{{if .MapKey -}}
+	case map[{{ .MapKey }}]{{ .Elem }}:
+		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(v, e)
+	case *map[{{ .MapKey }}]{{ .Elem }}:
+		if *v == nil {
+			e.e.EncodeNil()
+		} else {
+			fastpathTV.{{ .MethodNamePfx "Enc" false }}V(*v, e)
+		}
+{{end}}{{end}}{{end -}}
+
+	default:
+		_ = v // workaround https://github.com/golang/go/issues/12927 seen in go1.4
+		return false
+	}
+	return true
+}
+
+// -- -- fast path functions
+{{range .Values}}{{if not .Primitive}}{{if not .MapKey -}} 
+func (e *Encoder) {{ .MethodNamePfx "fastpathEnc" false }}R(f *codecFnInfo, rv reflect.Value) {
+	var v  []{{ .Elem }}
+	if rv.Kind() == reflect.Array {
+		rvGetSlice4Array(rv, &v)
+	} else {
+		v = rv2i(rv).([]{{ .Elem }})
+	}
+	if f.ti.mbs {
+		fastpathTV.{{ .MethodNamePfx "EncAsMap" false }}V(v, e)
+	} else {
+		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(v, e)
+	}
+}
+func (fastpathT) {{ .MethodNamePfx "Enc" false }}V(v []{{ .Elem }}, e *Encoder) {
+	{{/* if v == nil { e.e.EncodeNil(); return } */ -}}
+	{{ if eq .Elem "uint8" "byte" -}}
+	e.e.EncodeStringBytesRaw(v)
+	{{ else -}}
+	e.arrayStart(len(v))
+	for j := range v {
+		e.arrayElem()
+		{{ encmd .Elem "v[j]"}}
+	} 
+	e.arrayEnd()
+	{{ end -}}
+}
+func (fastpathT) {{ .MethodNamePfx "EncAsMap" false }}V(v []{{ .Elem }}, e *Encoder) {
+	{{/* if v == nil { e.e.EncodeNil() } else */ -}}
+	e.haltOnMbsOddLen(len(v))
+	{{/*
+	if len(v)&1 != 0 { // similar to &1==1 or %2 == 1
+		e.errorf(fastpathMapBySliceErrMsg, len(v))
+	}
+	*/ -}}
+	e.mapStart(len(v) >> 1) // e.mapStart(len(v) / 2)
+	for j := range v {
+		if j&1 == 0 { // if j%2 == 0 {
+			e.mapElemKey()
+		} else {
+			e.mapElemValue()
+		}
+		{{ encmd .Elem "v[j]"}}
+	}
+	e.mapEnd()
+}
+{{end}}{{end}}{{end -}}
+
+{{range .Values}}{{if not .Primitive}}{{if .MapKey -}}
+func (e *Encoder) {{ .MethodNamePfx "fastpathEnc" false }}R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.{{ .MethodNamePfx "Enc" false }}V(rv2i(rv).(map[{{ .MapKey }}]{{ .Elem }}), e)
+}
+func (fastpathT) {{ .MethodNamePfx "Enc" false }}V(v map[{{ .MapKey }}]{{ .Elem }}, e *Encoder) {
+	{{/* if v == nil { e.e.EncodeNil(); return } */ -}}
+	e.mapStart(len(v))
+	if e.h.Canonical { {{/* need to figure out .NoCanonical */}}
+		{{if eq .MapKey "interface{}"}}{{/* out of band */ -}}
+		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
+		e2 := NewEncoderBytes(&mksv, e.hh)
+		v2 := make([]bytesIntf, len(v))
+		var i, l uint {{/* put loop variables outside. seems currently needed for better perf */}}
+		var vp *bytesIntf
+		for k2 := range v {
+			l = uint(len(mksv))
+			e2.MustEncode(k2)
+			vp = &v2[i]
+			vp.v = mksv[l:]
+			vp.i = k2 
+			i++
+		}
+		sort.Sort(bytesIntfSlice(v2))
+		for j := range v2 {
+			e.mapElemKey()
+			e.asis(v2[j].v)
+			e.mapElemValue()
+			e.encode(v[v2[j].i])
+		} {{else}}{{ $x := sorttype .MapKey true}}v2 := make([]{{ $x }}, len(v))
+		var i uint
+		for k := range v {
+			v2[i] = {{if eq $x .MapKey}}k{{else}}{{ $x }}(k){{end}}
+			i++
+		}
+		sort.Sort({{ sorttype .MapKey false}}(v2))
+		for _, k2 := range v2 {
+			e.mapElemKey()
+			{{if eq .MapKey "string"}} e.e.EncodeString(k2) {{else}}{{ $y := printf "%s(k2)" .MapKey }}{{if eq $x .MapKey }}{{ $y = "k2" }}{{end}}{{ encmd .MapKey $y }}{{end}}
+			e.mapElemValue()
+			{{ $y := printf "v[%s(k2)]" .MapKey }}{{if eq $x .MapKey }}{{ $y = "v[k2]" }}{{end}}{{ encmd .Elem $y }}
+		} {{end}}
+	} else { 
+		for k2, v2 := range v {
+			e.mapElemKey()
+			{{if eq .MapKey "string"}} e.e.EncodeString(k2) {{else}}{{ encmd .MapKey "k2"}}{{end}}
+			e.mapElemValue()
+			{{ encmd .Elem "v2"}}
+		}
+	}
+	e.mapEnd()
+}
+{{end}}{{end}}{{end -}}
+
+// -- decode
+
+// -- -- fast path type switch
+func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool {
+	var changed bool
+	var containerLen int
+	switch v := iv.(type) {
+{{range .Values}}{{if not .Primitive}}{{if not .MapKey -}}
+	case []{{ .Elem }}:
+		fastpathTV.{{ .MethodNamePfx "Dec" false }}N(v, d)
+	case *[]{{ .Elem }}:
+		var v2 []{{ .Elem }}
+		if v2, changed = fastpathTV.{{ .MethodNamePfx "Dec" false }}Y(*v, d); changed {
+			*v = v2
+		}
+{{end}}{{end}}{{end -}}
+{{range .Values}}{{if not .Primitive}}{{if .MapKey }}{{/*
+// maps only change if nil, and in that case, there's no point copying
+*/ -}}
+	case map[{{ .MapKey }}]{{ .Elem }}:
+		containerLen = d.mapStart(d.d.ReadMapStart())
+		if containerLen != containerLenNil {
+			if containerLen != 0 {
+				fastpathTV.{{ .MethodNamePfx "Dec" false }}L(v, containerLen, d)
+			}
+			d.mapEnd()
+		}
+	case *map[{{ .MapKey }}]{{ .Elem }}:
+		{{/*
+		containerLen = d.mapStart(d.d.ReadMapStart())
+		if containerLen == 0 {
+			d.mapEnd()
+		} else if containerLen == containerLenNil {
+			*v = nil
+		} else {
+			if *v == nil {
+				*v = make(map[{{ .MapKey }}]{{ .Elem }}, decInferLen(containerLen, d.h.MaxInitLen, {{ .Size }}))
+			}
+			fastpathTV.{{ .MethodNamePfx "Dec" false }}L(*v, containerLen, d)
+		}
+		// consider delegating fully to X - encoding *map is uncommon, so ok to pay small function call cost
+		*/ -}}
+		fastpathTV.{{ .MethodNamePfx "Dec" false }}X(v, d)
+{{end}}{{end}}{{end -}}
+	default:
+		_ = v // workaround https://github.com/golang/go/issues/12927 seen in go1.4
+		return false
+	}
+	return true
+}
+
+func fastpathDecodeSetZeroTypeSwitch(iv interface{}) bool {
+	switch v := iv.(type) {
+{{range .Values}}{{if not .Primitive}}{{if not .MapKey -}}
+	case *[]{{ .Elem }}: 
+		*v = nil
+{{end}}{{end}}{{end}}
+{{range .Values}}{{if not .Primitive}}{{if .MapKey -}}
+	case *map[{{ .MapKey }}]{{ .Elem }}: 
+		*v = nil 
+{{end}}{{end}}{{end}}
+	default:
+		_ = v // workaround https://github.com/golang/go/issues/12927 seen in go1.4
+		return false
+	}
+	return true
+}
+
+// -- -- fast path functions
+{{range .Values}}{{if not .Primitive}}{{if not .MapKey -}}
+{{/*
+Slices can change if they
+- did not come from an array
+- are addressable (from a ptr)
+- are settable (e.g. contained in an interface{})
+*/}}
+func (d *Decoder) {{ .MethodNamePfx "fastpathDec" false }}R(f *codecFnInfo, rv reflect.Value) {
+	{{/*
+    // seqTypeArray=true means that we are not getting a pointer, so no need to check that.
+    if f.seq != seqTypeArray && rv.Kind() == reflect.Ptr {
+    */ -}}
+	var v  []{{ .Elem }}
+	switch rv.Kind() {
+	case reflect.Ptr:
+		vp := rv2i(rv).(*[]{{ .Elem }})
+		var changed bool
+		if v, changed = fastpathTV.{{ .MethodNamePfx "Dec" false }}Y(*vp, d); changed {
+			*vp = v
+		}
+	case reflect.Array:
+		rvGetSlice4Array(rv, &v)
+		fastpathTV.{{ .MethodNamePfx "Dec" false }}N(v, d)
+	default:
+		fastpathTV.{{ .MethodNamePfx "Dec" false }}N(rv2i(rv).([]{{ .Elem }}), d)
+	}
+}
+func (f fastpathT) {{ .MethodNamePfx "Dec" false }}X(vp *[]{{ .Elem }}, d *Decoder) {
+	if v, changed := f.{{ .MethodNamePfx "Dec" false }}Y(*vp, d); changed { *vp = v }
+}
+func (fastpathT) {{ .MethodNamePfx "Dec" false }}Y(v []{{ .Elem }}, d *Decoder) (v2 []{{ .Elem }}, changed bool) {
+	{{ if eq .Elem "uint8" "byte" -}}
+	switch d.d.ContainerType() {
+	case valueTypeNil, valueTypeMap:
+		break
+	default:
+		v2 = d.decodeBytesInto(v[:len(v):len(v)])
+		changed = !(len(v2) > 0 && len(v2) == len(v) && &v2[0] == &v[0]) // not same slice
+		return
+	}
+	{{ end -}}
+	slh, containerLenS := d.decSliceHelperStart()
+	if slh.IsNil {
+		if v == nil { return }
+		return nil, true
+	}
+	if containerLenS == 0 {
+		if v == nil { v = []{{ .Elem }}{} } else if len(v) != 0 { v = v[:0] }
+		slh.End()
+		return v, true
+	}
+	hasLen := containerLenS > 0
+	var xlen int 
+	if hasLen {
+		if containerLenS > cap(v) {
+			xlen = decInferLen(containerLenS, d.h.MaxInitLen, {{ .Size }})
+			if xlen <= cap(v) {
+				v = v[:uint(xlen)]
+			} else {
+				v = make([]{{ .Elem }}, uint(xlen))
+			}
+			changed = true 
+		} else if containerLenS != len(v) {
+			v = v[:containerLenS]
+			changed = true
+		}
+	}
+	var j int
+	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+		if j == 0 && len(v) == 0 { // means hasLen == false
+			xlen = decInferLen(containerLenS, d.h.MaxInitLen, {{ .Size }}) {{/* xlen = decDefSliceCap */}}
+			v = make([]{{ .Elem }}, uint(xlen))
+			changed = true
+		}
+		{{/* // if indefinite, etc, then expand the slice if necessary */ -}}
+		if j >= len(v) {
+			v = append(v, {{ zerocmd .Elem }})
+			changed = true
+		} 
+		slh.ElemContainerState(j)
+		{{ if eq .Elem "interface{}" }}d.decode(&v[uint(j)]){{ else }}v[uint(j)] = {{ decmd .Elem false }}{{ end }}
+	}
+	if j < len(v) {
+		v = v[:uint(j)]
+		changed = true
+	} else if j == 0 && v == nil {
+		v = []{{ .Elem }}{}
+		changed = true
+	}
+	slh.End()
+	return v, changed
+}
+func (fastpathT) {{ .MethodNamePfx "Dec" false }}N(v []{{ .Elem }}, d *Decoder) {
+	{{ if eq .Elem "uint8" "byte" -}}
+	switch d.d.ContainerType() {
+	case valueTypeNil, valueTypeMap:
+		break
+	default:
+		v2 := d.decodeBytesInto(v[:len(v):len(v)])
+		if !(len(v2) > 0 && len(v2) == len(v) && &v2[0] == &v[0]) { // not same slice
+			copy(v, v2)
+		}
+		return
+	}
+	{{ end -}}
+	slh, containerLenS := d.decSliceHelperStart()
+	if slh.IsNil {
+		return
+	}
+	if containerLenS == 0 {
+		slh.End()
+		return
+	}
+	hasLen := containerLenS > 0
+	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+		{{/* // if indefinite, etc, then expand the slice if necessary */ -}}
+		if j >= len(v) {
+			slh.arrayCannotExpand(hasLen, len(v), j, containerLenS)
+			return
+		} 
+		slh.ElemContainerState(j)
+		{{ if eq .Elem "interface{}" -}}
+		d.decode(&v[uint(j)])
+		{{- else -}}
+		v[uint(j)] = {{ decmd .Elem false }}
+		{{- end }}
+	}
+	slh.End()
+}
+{{end}}{{end}}{{end -}}
+
+{{range .Values}}{{if not .Primitive}}{{if .MapKey -}}
+{{/*
+Maps can change if they are
+- addressable (from a ptr)
+- settable (e.g. contained in an interface{})
+
+Also, these methods are called by decodeValue directly, after handling a TryNil.
+Consequently, there's no need to check for containerLenNil here.
+*/ -}}
+func (d *Decoder) {{ .MethodNamePfx "fastpathDec" false }}R(f *codecFnInfo, rv reflect.Value) {
+	containerLen := d.mapStart(d.d.ReadMapStart())
+    {{/*
+	if containerLen == containerLenNil {
+		if rv.Kind() == reflect.Ptr {
+			*(rv2i(rv).(*map[{{ .MapKey }}]{{ .Elem }})) = nil
+		}
+        return
+	}
+    */ -}}
+	if rv.Kind() == reflect.Ptr {
+		vp, _ := rv2i(rv).(*map[{{ .MapKey }}]{{ .Elem }})
+		if *vp == nil {
+			*vp = make(map[{{ .MapKey }}]{{ .Elem }}, decInferLen(containerLen, d.h.MaxInitLen, {{ .Size }}))
+		}
+		if containerLen != 0 {
+			fastpathTV.{{ .MethodNamePfx "Dec" false }}L(*vp, containerLen, d)
+		}
+	} else if containerLen != 0 {
+		fastpathTV.{{ .MethodNamePfx "Dec" false }}L(rv2i(rv).(map[{{ .MapKey }}]{{ .Elem }}), containerLen, d)
+	}
+	d.mapEnd()
+}
+func (f fastpathT) {{ .MethodNamePfx "Dec" false }}X(vp *map[{{ .MapKey }}]{{ .Elem }}, d *Decoder) {
+	containerLen := d.mapStart(d.d.ReadMapStart())
+	if containerLen == containerLenNil {
+		*vp = nil
+	} else {
+		if *vp == nil {
+			*vp = make(map[{{ .MapKey }}]{{ .Elem }}, decInferLen(containerLen, d.h.MaxInitLen, {{ .Size }}))
+		}
+		if containerLen != 0 {
+			f.{{ .MethodNamePfx "Dec" false }}L(*vp, containerLen, d)
+		}
+		d.mapEnd()
+	}
+}
+func (fastpathT) {{ .MethodNamePfx "Dec" false }}L(v map[{{ .MapKey }}]{{ .Elem }}, containerLen int, d *Decoder) {
+	{{/* No need to check if containerLen == containerLenNil, as that is checked by R and L above  */ -}}
+	if v == nil {
+		d.errorf("cannot decode into nil map[{{ .MapKey }}]{{ .Elem }} given stream length: %v", containerLen)
+        {{/* d.swallowMapContents(containerLen) */ -}}
+		return
+	}
+	{{if eq .Elem "interface{}" }}mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
+    {{else if eq .Elem "bytes" "[]byte" }}mapGet := v != nil && !d.h.MapValueReset
+    {{end -}}
+    var mk {{ .MapKey }}
+	var mv {{ .Elem }}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+		d.mapElemKey()
+		{{ if eq .MapKey "interface{}" }}mk = nil 
+		d.decode(&mk)
+		if bv, bok := mk.([]byte); bok {
+			mk = d.stringZC(bv) {{/* // maps cannot have []byte as key. switch to string. */}}
+		}{{ else }}mk = {{ decmd .MapKey true }}{{ end }}
+		d.mapElemValue()
+		{{ if eq .Elem "interface{}" "[]byte" "bytes" -}}
+		if mapGet { mv = v[mk] } else { mv = nil }
+		{{ end -}}
+		{{ if eq .Elem "interface{}" -}}
+		d.decode(&mv)
+		{{ else if eq .Elem "[]byte" "bytes" -}}
+		mv = d.decodeBytesInto(mv)
+		{{ else -}}
+		mv = {{ decmd .Elem false }}
+		{{ end -}}
+		v[mk] = mv
+	}
+}
+{{end}}{{end}}{{end}}

vendor/github.com/ugorji/go/codec/fast-path.not.go

@@ -0,0 +1,41 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build notfastpath || codec.notfastpath
+// +build notfastpath codec.notfastpath
+
+package codec
+
+import "reflect"
+
+const fastpathEnabled = false
+
+// The generated fast-path code is very large, and adds a few seconds to the build time.
+// This causes test execution, execution of small tools which use codec, etc
+// to take a long time.
+//
+// To mitigate, we now support the notfastpath tag.
+// This tag disables fastpath during build, allowing for faster build, test execution,
+// short-program runs, etc.
+
+func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool { return false }
+func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool { return false }
+
+// func fastpathEncodeTypeSwitchSlice(iv interface{}, e *Encoder) bool { return false }
+// func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool   { return false }
+
+func fastpathDecodeSetZeroTypeSwitch(iv interface{}) bool { return false }
+
+type fastpathT struct{}
+type fastpathE struct {
+	rtid  uintptr
+	rt    reflect.Type
+	encfn func(*Encoder, *codecFnInfo, reflect.Value)
+	decfn func(*Decoder, *codecFnInfo, reflect.Value)
+}
+type fastpathA [0]fastpathE
+
+func fastpathAvIndex(rtid uintptr) int { return -1 }
+
+var fastpathAv fastpathA
+var fastpathTV fastpathT

vendor/github.com/ugorji/go/codec/gen-dec-array.go.tmpl

@@ -0,0 +1,90 @@
+{{var "v"}} := {{if not isArray}}*{{end}}{{ .Varname }}
+{{var "h"}}, {{var "l"}} := z.DecSliceHelperStart() {{/* // helper, containerLenS */}}
+{{if not isArray -}}
+var {{var "c"}} bool {{/* // changed */}}
+_ = {{var "c"}}
+if {{var "h"}}.IsNil {
+	if {{var "v"}} != nil {
+		{{var "v"}} = nil
+		{{var "c"}} = true
+	}
+} else {{end -}}
+if {{var "l"}} == 0 {
+	{{if isSlice -}}
+	if {{var "v"}} == nil {
+		{{var "v"}} = []{{ .Typ }}{}
+		{{var "c"}} = true
+	} else if len({{var "v"}}) != 0 {
+		{{var "v"}} = {{var "v"}}[:0]
+		{{var "c"}} = true
+	} {{else if isChan }}if {{var "v"}} == nil {
+		{{var "v"}} = make({{ .CTyp }}, 0)
+		{{var "c"}} = true
+	}
+    {{end -}}
+} else {
+	{{var "hl"}} := {{var "l"}} > 0
+	var {{var "rl"}} int
+	_ =  {{var "rl"}}
+	{{if isSlice }} if {{var "hl"}} {
+	if {{var "l"}} > cap({{var "v"}}) {
+		{{var "rl"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
+		if {{var "rl"}} <= cap({{var "v"}}) {
+			{{var "v"}} = {{var "v"}}[:{{var "rl"}}]
+		} else {
+			{{var "v"}} = make([]{{ .Typ }}, {{var "rl"}})
+		}
+		{{var "c"}} = true
+	} else if {{var "l"}} != len({{var "v"}}) {
+		{{var "v"}} = {{var "v"}}[:{{var "l"}}]
+		{{var "c"}} = true
+	}
+	}
+    {{end -}}
+	var {{var "j"}} int 
+    {{/* // var {{var "dn"}} bool */ -}}
+	for {{var "j"}} = 0; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || z.DecCheckBreak()); {{var "j"}}++ { // bounds-check-elimination
+		{{if not isArray}} if {{var "j"}} == 0 && {{var "v"}} == nil {
+			if {{var "hl"}} {
+				{{var "rl"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
+			} else {
+				{{var "rl"}} = {{if isSlice}}8{{else if isChan}}64{{end}}
+			}
+			{{var "v"}} = make({{if isSlice}}[]{{ .Typ }}{{else if isChan}}{{.CTyp}}{{end}}, {{var "rl"}})
+			{{var "c"}} = true 
+		}
+        {{end -}}
+		{{var "h"}}.ElemContainerState({{var "j"}})
+        {{/* {{var "dn"}} = r.TryDecodeAsNil() */}}{{/* commented out, as decLineVar handles this already each time */ -}}
+        {{if isChan}}{{ $x := printf "%[1]vvcx%[2]v" .TempVar .Rand }}var {{$x}} {{ .Typ }}
+		{{ decLineVar $x -}}
+		{{var "v"}} <- {{ $x }}
+        {{else}}{{/* // if indefinite, etc, then expand the slice if necessary */ -}}
+		var {{var "db"}} bool
+		if {{var "j"}} >= len({{var "v"}}) {
+			{{if isSlice }} {{var "v"}} = append({{var "v"}}, {{ zero }})
+			{{var "c"}} = true
+			{{else}} z.DecArrayCannotExpand(len(v), {{var "j"}}+1); {{var "db"}} = true
+			{{end -}}
+		}
+		if {{var "db"}} {
+			z.DecSwallow()
+		} else {
+			{{ $x := printf "%[1]vv%[2]v[%[1]vj%[2]v]" .TempVar .Rand }}{{ decLineVar $x -}}
+		}
+        {{end -}}
+	}
+	{{if isSlice}} if {{var "j"}} < len({{var "v"}}) {
+		{{var "v"}} = {{var "v"}}[:{{var "j"}}]
+		{{var "c"}} = true
+	} else if {{var "j"}} == 0 && {{var "v"}} == nil {
+		{{var "v"}} = make([]{{ .Typ }}, 0)
+		{{var "c"}} = true
+	}
+    {{end -}}
+}
+{{var "h"}}.End()
+{{if not isArray }}if {{var "c"}} { 
+	*{{ .Varname }} = {{var "v"}}
+}
+{{end -}}

vendor/github.com/ugorji/go/codec/gen-dec-map.go.tmpl

@@ -0,0 +1,58 @@
+{{var "v"}} := *{{ .Varname }}
+{{var "l"}} := z.DecReadMapStart()
+if {{var "l"}} == codecSelferDecContainerLenNil{{xs}} {
+	*{{ .Varname }} = nil
+} else {
+if {{var "v"}} == nil {
+	{{var "rl"}} := z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
+	{{var "v"}} = make(map[{{ .KTyp }}]{{ .Typ }}, {{var "rl"}})
+	*{{ .Varname }} = {{var "v"}}
+}
+{{ $mk := var "mk" -}}
+var {{ $mk }} {{ .KTyp }}
+var {{var "mv"}} {{ .Typ }}
+var {{var "mg"}}, {{var "mdn"}} {{if decElemKindPtr}}, {{var "ms"}}, {{var "mok"}}{{end}} bool
+if z.DecBasicHandle().MapValueReset {
+	{{if decElemKindPtr}}{{var "mg"}} = true
+	{{else if decElemKindIntf}}if !z.DecBasicHandle().InterfaceReset { {{var "mg"}} = true }
+	{{else if not decElemKindImmutable}}{{var "mg"}} = true
+	{{end}} }
+if {{var "l"}} != 0 {
+	{{var "hl"}} := {{var "l"}} > 0 
+	for {{var "j"}} := 0; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || z.DecCheckBreak()); {{var "j"}}++ {
+	z.DecReadMapElemKey()
+	{{ if eq .KTyp "string" -}}
+		{{ decLineVarK $mk -}}{{- /* decLineVarKStrZC $mk */ -}}
+	{{ else -}}
+		{{ decLineVarK $mk -}}
+	{{ end -}}
+	{{ if eq .KTyp "interface{}" }}{{/* // special case if a byte array. */ -}}
+    if {{var "bv"}}, {{var "bok"}} := {{var "mk"}}.([]byte); {{var "bok"}} {
+		{{var "mk"}} = z.DecStringZC({{var "bv"}})
+	}
+    {{ end -}}
+    {{if decElemKindPtr -}}
+	{{var "ms"}} = true
+    {{end -}}
+	if {{var "mg"}} {
+		{{if decElemKindPtr -}}
+        {{var "mv"}}, {{var "mok"}} = {{var "v"}}[{{ $mk }}]
+		if {{var "mok"}} {
+			{{var "ms"}} = false
+		}
+        {{else -}}
+        {{var "mv"}} = {{var "v"}}[{{ $mk }}]
+        {{end -}}
+	} {{if not decElemKindImmutable}}else { {{var "mv"}} = {{decElemZero}} }{{end}}
+	z.DecReadMapElemValue()
+	{{var "mdn"}} = false
+	{{ $x := printf "%vmv%v" .TempVar .Rand }}{{ $y := printf "%vmdn%v" .TempVar .Rand }}{{ decLineVar $x $y -}}
+	if {{var "mdn"}} {
+		{{var "v"}}[{{ $mk }}] = {{decElemZero}}
+	} else {{if decElemKindPtr}} if {{var "ms"}} {{end}} {
+		{{var "v"}}[{{ $mk }}] = {{var "mv"}}
+	}
+}
+} // else len==0: leave as-is (do not clear map entries)
+z.DecReadMapEnd()
+}

vendor/github.com/ugorji/go/codec/gen-enc-chan.go.tmpl

@@ -0,0 +1,27 @@
+{{.Label}}:
+switch timeout{{.Sfx}} :=  z.EncBasicHandle().ChanRecvTimeout; {
+case timeout{{.Sfx}} == 0: // only consume available
+	for {
+		select {
+		case b{{.Sfx}} := <-{{.Chan}}:
+			{{ .Slice }} = append({{.Slice}}, b{{.Sfx}})
+		default:
+			break {{.Label}}
+		}
+	}
+case timeout{{.Sfx}} > 0: // consume until timeout
+	tt{{.Sfx}} := time.NewTimer(timeout{{.Sfx}})
+	for {
+		select {
+		case b{{.Sfx}} := <-{{.Chan}}:
+			{{.Slice}} = append({{.Slice}}, b{{.Sfx}})
+		case <-tt{{.Sfx}}.C:
+			// close(tt.C)
+			break {{.Label}}
+		}
+	}
+default: // consume until close
+	for b{{.Sfx}} := range {{.Chan}} {
+		{{.Slice}} = append({{.Slice}}, b{{.Sfx}})
+	}
+}

vendor/github.com/ugorji/go/codec/gen-helper.generated.go

@@ -0,0 +1,277 @@
+// comment this out // + build ignore
+
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+// Code generated from gen-helper.go.tmpl - DO NOT EDIT.
+
+package codec
+
+import (
+	"encoding"
+	"reflect"
+)
+
+// GenVersion is the current version of codecgen.
+const GenVersion = 25
+
+// This file is used to generate helper code for codecgen.
+// The values here i.e. genHelper(En|De)coder are not to be used directly by
+// library users. They WILL change continuously and without notice.
+
+// GenHelperEncoder is exported so that it can be used externally by codecgen.
+//
+// Library users: DO NOT USE IT DIRECTLY or INDIRECTLY. IT WILL CHANGE CONTINOUSLY WITHOUT NOTICE.
+func GenHelper() (g genHelper) { return }
+
+type genHelper struct{}
+
+func (genHelper) Encoder(e *Encoder) (ge genHelperEncoder, ee genHelperEncDriver) {
+	ge = genHelperEncoder{e: e}
+	ee = genHelperEncDriver{encDriver: e.e}
+	return
+}
+
+func (genHelper) Decoder(d *Decoder) (gd genHelperDecoder, dd genHelperDecDriver) {
+	gd = genHelperDecoder{d: d}
+	dd = genHelperDecDriver{decDriver: d.d}
+	return
+}
+
+type genHelperEncDriver struct {
+	encDriver
+}
+
+type genHelperDecDriver struct {
+	decDriver
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+type genHelperEncoder struct {
+	M mustHdl
+	F fastpathT
+	e *Encoder
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+type genHelperDecoder struct {
+	C checkOverflow
+	F fastpathT
+	d *Decoder
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncBasicHandle() *BasicHandle {
+	return f.e.h
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncBinary() bool {
+	return f.e.be // f.e.hh.isBinaryEncoding()
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) IsJSONHandle() bool {
+	return f.e.js
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncFallback(iv interface{}) {
+	// f.e.encodeI(iv, false, false)
+	f.e.encodeValue(reflect.ValueOf(iv), nil)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncTextMarshal(iv encoding.TextMarshaler) {
+	bs, fnerr := iv.MarshalText()
+	f.e.marshalUtf8(bs, fnerr)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncJSONMarshal(iv jsonMarshaler) {
+	bs, fnerr := iv.MarshalJSON()
+	f.e.marshalAsis(bs, fnerr)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncBinaryMarshal(iv encoding.BinaryMarshaler) {
+	bs, fnerr := iv.MarshalBinary()
+	f.e.marshalRaw(bs, fnerr)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncRaw(iv Raw) { f.e.rawBytes(iv) }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) Extension(v interface{}) (xfn *extTypeTagFn) {
+	return f.e.h.getExtForI(v)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncExtension(v interface{}, xfFn *extTypeTagFn) {
+	f.e.e.EncodeExt(v, xfFn.rt, xfFn.tag, xfFn.ext)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) WriteStr(s string) {
+	f.e.w().writestr(s)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncWriteMapStart(length int) { f.e.mapStart(length) }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncWriteMapEnd() { f.e.mapEnd() }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncWriteArrayStart(length int) { f.e.arrayStart(length) }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncWriteArrayEnd() { f.e.arrayEnd() }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncWriteArrayElem() { f.e.arrayElem() }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncWriteMapElemKey() { f.e.mapElemKey() }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncWriteMapElemValue() { f.e.mapElemValue() }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncEncodeComplex64(v complex64) { f.e.encodeComplex64(v) }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncEncodeComplex128(v complex128) { f.e.encodeComplex128(v) }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncEncode(v interface{}) { f.e.encode(v) }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncEncodeMapNonNil(v interface{}) {
+	if skipFastpathTypeSwitchInDirectCall || !fastpathEncodeTypeSwitch(v, f.e) {
+		f.e.encodeValue(reflect.ValueOf(v), nil)
+	}
+}
+
+// ---------------- DECODER FOLLOWS -----------------
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecBasicHandle() *BasicHandle {
+	return f.d.h
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecBinary() bool {
+	return f.d.be // f.d.hh.isBinaryEncoding()
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecSwallow() { f.d.swallow() }
+
+// // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+// func (f genHelperDecoder) DecScratchBuffer() []byte {
+// 	return f.d.b[:]
+// }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecScratchArrayBuffer() *[decScratchByteArrayLen]byte {
+	return &f.d.b
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecFallback(iv interface{}, chkPtr bool) {
+	rv := reflect.ValueOf(iv)
+	if chkPtr {
+		if x, _ := isDecodeable(rv); !x {
+			f.d.haltAsNotDecodeable(rv)
+		}
+	}
+	f.d.decodeValue(rv, nil)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecSliceHelperStart() (decSliceHelper, int) {
+	return f.d.decSliceHelperStart()
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecStructFieldNotFound(index int, name string) {
+	f.d.structFieldNotFound(index, name)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecArrayCannotExpand(sliceLen, streamLen int) {
+	f.d.arrayCannotExpand(sliceLen, streamLen)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecTextUnmarshal(tm encoding.TextUnmarshaler) {
+	halt.onerror(tm.UnmarshalText(f.d.d.DecodeStringAsBytes()))
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecJSONUnmarshal(tm jsonUnmarshaler) {
+	f.d.jsonUnmarshalV(tm)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecBinaryUnmarshal(bm encoding.BinaryUnmarshaler) {
+	halt.onerror(bm.UnmarshalBinary(f.d.d.DecodeBytes(nil)))
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecRaw() []byte { return f.d.rawBytes() }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) IsJSONHandle() bool {
+	return f.d.js
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) Extension(v interface{}) (xfn *extTypeTagFn) {
+	return f.d.h.getExtForI(v)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecExtension(v interface{}, xfFn *extTypeTagFn) {
+	f.d.d.DecodeExt(v, xfFn.rt, xfFn.tag, xfFn.ext)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecInferLen(clen, maxlen, unit int) (rvlen int) {
+	return decInferLen(clen, maxlen, unit)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecReadMapStart() int { return f.d.mapStart(f.d.d.ReadMapStart()) }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecReadMapEnd() { f.d.mapEnd() }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecReadArrayStart() int { return f.d.arrayStart(f.d.d.ReadArrayStart()) }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecReadArrayEnd() { f.d.arrayEnd() }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecReadArrayElem() { f.d.arrayElem() }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecReadMapElemKey() { f.d.mapElemKey() }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecReadMapElemValue() { f.d.mapElemValue() }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecDecodeFloat32() float32 { return f.d.decodeFloat32() }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecCheckBreak() bool { return f.d.checkBreak() }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecStringZC(v []byte) string { return f.d.stringZC(v) }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecodeBytesInto(v []byte) []byte { return f.d.decodeBytesInto(v) }

vendor/github.com/ugorji/go/codec/gen-helper.go.tmpl

@@ -0,0 +1,249 @@
+// comment this out // + build ignore
+
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+// Code generated from gen-helper.go.tmpl - DO NOT EDIT.
+
+package codec
+
+import (
+	"encoding"
+	"reflect"
+)
+
+// GenVersion is the current version of codecgen.
+const GenVersion = {{ .Version }} 
+
+// This file is used to generate helper code for codecgen. 
+// The values here i.e. genHelper(En|De)coder are not to be used directly by 
+// library users. They WILL change continuously and without notice.
+
+{{/*
+// To help enforce this, we create an unexported type with exported members.
+// The only way to get the type is via the one exported type that we control (somewhat).
+//
+// When static codecs are created for types, they will use this value
+// to perform encoding or decoding of primitives or known slice or map types.
+*/ -}}
+
+// GenHelperEncoder is exported so that it can be used externally by codecgen.
+//
+// Library users: DO NOT USE IT DIRECTLY or INDIRECTLY. IT WILL CHANGE CONTINOUSLY WITHOUT NOTICE.
+func GenHelper() (g genHelper) { return }
+
+type genHelper struct {}
+
+func (genHelper) Encoder(e *Encoder) (ge genHelperEncoder, ee genHelperEncDriver) {
+	ge = genHelperEncoder{e: e}
+	ee = genHelperEncDriver{encDriver: e.e}
+	return 
+}
+
+func (genHelper) Decoder(d *Decoder) (gd genHelperDecoder, dd genHelperDecDriver) {
+	gd = genHelperDecoder{d: d}
+	dd = genHelperDecDriver{decDriver: d.d}
+	return
+}
+
+type genHelperEncDriver struct {
+	encDriver
+}
+
+type genHelperDecDriver struct {
+	decDriver
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+type genHelperEncoder struct {
+	M mustHdl
+	F fastpathT 
+	e *Encoder
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+type genHelperDecoder struct {
+	C checkOverflow
+	F fastpathT 
+	d *Decoder
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncBasicHandle() *BasicHandle {
+	return f.e.h
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncBinary() bool {
+	return f.e.be // f.e.hh.isBinaryEncoding()
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) IsJSONHandle() bool {
+	return f.e.js
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncFallback(iv interface{}) {
+	// f.e.encodeI(iv, false, false)
+	f.e.encodeValue(reflect.ValueOf(iv), nil)
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncTextMarshal(iv encoding.TextMarshaler) {
+	bs, fnerr := iv.MarshalText()
+	f.e.marshalUtf8(bs, fnerr)
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncJSONMarshal(iv jsonMarshaler) {
+	bs, fnerr := iv.MarshalJSON()
+	f.e.marshalAsis(bs, fnerr)
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncBinaryMarshal(iv encoding.BinaryMarshaler) {
+	bs, fnerr := iv.MarshalBinary()
+	f.e.marshalRaw(bs, fnerr)
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncRaw(iv Raw) { f.e.rawBytes(iv) }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) Extension(v interface{}) (xfn *extTypeTagFn) {
+	return f.e.h.getExtForI(v)
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncExtension(v interface{}, xfFn *extTypeTagFn) {
+	f.e.e.EncodeExt(v, xfFn.rt, xfFn.tag, xfFn.ext)
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) WriteStr(s string) {
+	f.e.w().writestr(s)
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncWriteMapStart(length int) { f.e.mapStart(length) }
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncWriteMapEnd() { f.e.mapEnd() }
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncWriteArrayStart(length int) { f.e.arrayStart(length) }
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncWriteArrayEnd() { f.e.arrayEnd() }
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncWriteArrayElem() { f.e.arrayElem() }
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncWriteMapElemKey() { f.e.mapElemKey() }
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncWriteMapElemValue() { f.e.mapElemValue() }
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncEncodeComplex64(v complex64) { f.e.encodeComplex64(v) }
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncEncodeComplex128(v complex128) { f.e.encodeComplex128(v) }
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncEncode(v interface{}) { f.e.encode(v) }
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncEncodeMapNonNil(v interface{}) {
+	if skipFastpathTypeSwitchInDirectCall || !fastpathEncodeTypeSwitch(v, f.e) {
+		f.e.encodeValue(reflect.ValueOf(v), nil)
+	}
+}
+
+// ---------------- DECODER FOLLOWS -----------------
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecBasicHandle() *BasicHandle {
+	return f.d.h
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecBinary() bool {
+     return f.d.be // f.d.hh.isBinaryEncoding()
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecSwallow() { f.d.swallow() }
+
+// // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+// func (f genHelperDecoder) DecScratchBuffer() []byte {
+// 	return f.d.b[:]
+// }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecScratchArrayBuffer() *[decScratchByteArrayLen]byte {
+	return &f.d.b
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecFallback(iv interface{}, chkPtr bool) {
+	rv := reflect.ValueOf(iv)
+	if chkPtr {
+    	if x, _ := isDecodeable(rv); !x {
+			f.d.haltAsNotDecodeable(rv)
+		}
+	}
+	f.d.decodeValue(rv, nil)
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecSliceHelperStart() (decSliceHelper, int) {
+	return f.d.decSliceHelperStart()
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecStructFieldNotFound(index int, name string) {
+	f.d.structFieldNotFound(index, name)
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecArrayCannotExpand(sliceLen, streamLen int) {
+	f.d.arrayCannotExpand(sliceLen, streamLen)
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecTextUnmarshal(tm encoding.TextUnmarshaler) {
+	halt.onerror(tm.UnmarshalText(f.d.d.DecodeStringAsBytes()))
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecJSONUnmarshal(tm jsonUnmarshaler) {
+	f.d.jsonUnmarshalV(tm)
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecBinaryUnmarshal(bm encoding.BinaryUnmarshaler) {
+	halt.onerror(bm.UnmarshalBinary(f.d.d.DecodeBytes(nil)))
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecRaw() []byte {	return f.d.rawBytes() }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) IsJSONHandle() bool {
+	return f.d.js 
+}
+{{/*
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) I2Rtid(v interface{}) uintptr {
+	return i2rtid(v)
+}
+*/ -}}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) Extension(v interface{}) (xfn *extTypeTagFn) {
+	return f.d.h.getExtForI(v)
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecExtension(v interface{}, xfFn *extTypeTagFn) {
+	f.d.d.DecodeExt(v, xfFn.rt, xfFn.tag, xfFn.ext)
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecInferLen(clen, maxlen, unit int) (rvlen int) {
+	return decInferLen(clen, maxlen, unit)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecReadMapStart() int { return f.d.mapStart(f.d.d.ReadMapStart()) }
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecReadMapEnd() { f.d.mapEnd() }
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecReadArrayStart() int { return f.d.arrayStart(f.d.d.ReadArrayStart()) }
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecReadArrayEnd() { f.d.arrayEnd() }
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecReadArrayElem() { f.d.arrayElem() }
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecReadMapElemKey() { f.d.mapElemKey() }
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecReadMapElemValue() { f.d.mapElemValue() }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecDecodeFloat32() float32 { return f.d.decodeFloat32() }
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecCheckBreak() bool { return f.d.checkBreak() }
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecStringZC(v []byte) string { return f.d.stringZC(v) }
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecodeBytesInto(v []byte) []byte { return f.d.decodeBytesInto(v) }

vendor/github.com/ugorji/go/codec/gen.generated.go

@@ -0,0 +1,192 @@
+// +build codecgen.exec
+
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+package codec
+
+// DO NOT EDIT. THIS FILE IS AUTO-GENERATED FROM gen-dec-(map|array).go.tmpl
+
+const genDecMapTmpl = `
+{{var "v"}} := *{{ .Varname }}
+{{var "l"}} := z.DecReadMapStart()
+if {{var "l"}} == codecSelferDecContainerLenNil{{xs}} {
+	*{{ .Varname }} = nil
+} else {
+if {{var "v"}} == nil {
+	{{var "rl"}} := z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
+	{{var "v"}} = make(map[{{ .KTyp }}]{{ .Typ }}, {{var "rl"}})
+	*{{ .Varname }} = {{var "v"}}
+}
+{{ $mk := var "mk" -}}
+var {{ $mk }} {{ .KTyp }}
+var {{var "mv"}} {{ .Typ }}
+var {{var "mg"}}, {{var "mdn"}} {{if decElemKindPtr}}, {{var "ms"}}, {{var "mok"}}{{end}} bool
+if z.DecBasicHandle().MapValueReset {
+	{{if decElemKindPtr}}{{var "mg"}} = true
+	{{else if decElemKindIntf}}if !z.DecBasicHandle().InterfaceReset { {{var "mg"}} = true }
+	{{else if not decElemKindImmutable}}{{var "mg"}} = true
+	{{end}} }
+if {{var "l"}} != 0 {
+	{{var "hl"}} := {{var "l"}} > 0 
+	for {{var "j"}} := 0; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || z.DecCheckBreak()); {{var "j"}}++ {
+	z.DecReadMapElemKey()
+	{{ if eq .KTyp "string" -}}
+		{{ decLineVarK $mk -}}{{- /* decLineVarKStrZC $mk */ -}}
+	{{ else -}}
+		{{ decLineVarK $mk -}}
+	{{ end -}}
+	{{ if eq .KTyp "interface{}" }}{{/* // special case if a byte array. */ -}}
+    if {{var "bv"}}, {{var "bok"}} := {{var "mk"}}.([]byte); {{var "bok"}} {
+		{{var "mk"}} = z.DecStringZC({{var "bv"}})
+	}
+    {{ end -}}
+    {{if decElemKindPtr -}}
+	{{var "ms"}} = true
+    {{end -}}
+	if {{var "mg"}} {
+		{{if decElemKindPtr -}}
+        {{var "mv"}}, {{var "mok"}} = {{var "v"}}[{{ $mk }}]
+		if {{var "mok"}} {
+			{{var "ms"}} = false
+		}
+        {{else -}}
+        {{var "mv"}} = {{var "v"}}[{{ $mk }}]
+        {{end -}}
+	} {{if not decElemKindImmutable}}else { {{var "mv"}} = {{decElemZero}} }{{end}}
+	z.DecReadMapElemValue()
+	{{var "mdn"}} = false
+	{{ $x := printf "%vmv%v" .TempVar .Rand }}{{ $y := printf "%vmdn%v" .TempVar .Rand }}{{ decLineVar $x $y -}}
+	if {{var "mdn"}} {
+		{{var "v"}}[{{ $mk }}] = {{decElemZero}}
+	} else {{if decElemKindPtr}} if {{var "ms"}} {{end}} {
+		{{var "v"}}[{{ $mk }}] = {{var "mv"}}
+	}
+}
+} // else len==0: leave as-is (do not clear map entries)
+z.DecReadMapEnd()
+}
+`
+
+const genDecListTmpl = `
+{{var "v"}} := {{if not isArray}}*{{end}}{{ .Varname }}
+{{var "h"}}, {{var "l"}} := z.DecSliceHelperStart() {{/* // helper, containerLenS */}}
+{{if not isArray -}}
+var {{var "c"}} bool {{/* // changed */}}
+_ = {{var "c"}}
+if {{var "h"}}.IsNil {
+	if {{var "v"}} != nil {
+		{{var "v"}} = nil
+		{{var "c"}} = true
+	}
+} else {{end -}}
+if {{var "l"}} == 0 {
+	{{if isSlice -}}
+	if {{var "v"}} == nil {
+		{{var "v"}} = []{{ .Typ }}{}
+		{{var "c"}} = true
+	} else if len({{var "v"}}) != 0 {
+		{{var "v"}} = {{var "v"}}[:0]
+		{{var "c"}} = true
+	} {{else if isChan }}if {{var "v"}} == nil {
+		{{var "v"}} = make({{ .CTyp }}, 0)
+		{{var "c"}} = true
+	}
+    {{end -}}
+} else {
+	{{var "hl"}} := {{var "l"}} > 0
+	var {{var "rl"}} int
+	_ =  {{var "rl"}}
+	{{if isSlice }} if {{var "hl"}} {
+	if {{var "l"}} > cap({{var "v"}}) {
+		{{var "rl"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
+		if {{var "rl"}} <= cap({{var "v"}}) {
+			{{var "v"}} = {{var "v"}}[:{{var "rl"}}]
+		} else {
+			{{var "v"}} = make([]{{ .Typ }}, {{var "rl"}})
+		}
+		{{var "c"}} = true
+	} else if {{var "l"}} != len({{var "v"}}) {
+		{{var "v"}} = {{var "v"}}[:{{var "l"}}]
+		{{var "c"}} = true
+	}
+	}
+    {{end -}}
+	var {{var "j"}} int 
+    {{/* // var {{var "dn"}} bool */ -}}
+	for {{var "j"}} = 0; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || z.DecCheckBreak()); {{var "j"}}++ { // bounds-check-elimination
+		{{if not isArray}} if {{var "j"}} == 0 && {{var "v"}} == nil {
+			if {{var "hl"}} {
+				{{var "rl"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
+			} else {
+				{{var "rl"}} = {{if isSlice}}8{{else if isChan}}64{{end}}
+			}
+			{{var "v"}} = make({{if isSlice}}[]{{ .Typ }}{{else if isChan}}{{.CTyp}}{{end}}, {{var "rl"}})
+			{{var "c"}} = true 
+		}
+        {{end -}}
+		{{var "h"}}.ElemContainerState({{var "j"}})
+        {{/* {{var "dn"}} = r.TryDecodeAsNil() */}}{{/* commented out, as decLineVar handles this already each time */ -}}
+        {{if isChan}}{{ $x := printf "%[1]vvcx%[2]v" .TempVar .Rand }}var {{$x}} {{ .Typ }}
+		{{ decLineVar $x -}}
+		{{var "v"}} <- {{ $x }}
+        {{else}}{{/* // if indefinite, etc, then expand the slice if necessary */ -}}
+		var {{var "db"}} bool
+		if {{var "j"}} >= len({{var "v"}}) {
+			{{if isSlice }} {{var "v"}} = append({{var "v"}}, {{ zero }})
+			{{var "c"}} = true
+			{{else}} z.DecArrayCannotExpand(len(v), {{var "j"}}+1); {{var "db"}} = true
+			{{end -}}
+		}
+		if {{var "db"}} {
+			z.DecSwallow()
+		} else {
+			{{ $x := printf "%[1]vv%[2]v[%[1]vj%[2]v]" .TempVar .Rand }}{{ decLineVar $x -}}
+		}
+        {{end -}}
+	}
+	{{if isSlice}} if {{var "j"}} < len({{var "v"}}) {
+		{{var "v"}} = {{var "v"}}[:{{var "j"}}]
+		{{var "c"}} = true
+	} else if {{var "j"}} == 0 && {{var "v"}} == nil {
+		{{var "v"}} = make([]{{ .Typ }}, 0)
+		{{var "c"}} = true
+	}
+    {{end -}}
+}
+{{var "h"}}.End()
+{{if not isArray }}if {{var "c"}} { 
+	*{{ .Varname }} = {{var "v"}}
+}
+{{end -}}
+`
+
+const genEncChanTmpl = `
+{{.Label}}:
+switch timeout{{.Sfx}} :=  z.EncBasicHandle().ChanRecvTimeout; {
+case timeout{{.Sfx}} == 0: // only consume available
+	for {
+		select {
+		case b{{.Sfx}} := <-{{.Chan}}:
+			{{ .Slice }} = append({{.Slice}}, b{{.Sfx}})
+		default:
+			break {{.Label}}
+		}
+	}
+case timeout{{.Sfx}} > 0: // consume until timeout
+	tt{{.Sfx}} := time.NewTimer(timeout{{.Sfx}})
+	for {
+		select {
+		case b{{.Sfx}} := <-{{.Chan}}:
+			{{.Slice}} = append({{.Slice}}, b{{.Sfx}})
+		case <-tt{{.Sfx}}.C:
+			// close(tt.C)
+			break {{.Label}}
+		}
+	}
+default: // consume until close
+	for b{{.Sfx}} := range {{.Chan}} {
+		{{.Slice}} = append({{.Slice}}, b{{.Sfx}})
+	}
+}
+`

vendor/github.com/ugorji/go/codec/go.mod

@@ -0,0 +1,5 @@
+module github.com/ugorji/go/codec
+
+go 1.11
+
+require github.com/ugorji/go v1.2.6

vendor/github.com/ugorji/go/codec/goversion_arrayof_gte_go15.go

@@ -0,0 +1,15 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build go1.5
+// +build go1.5
+
+package codec
+
+import "reflect"
+
+const reflectArrayOfSupported = true
+
+func reflectArrayOf(count int, elem reflect.Type) reflect.Type {
+	return reflect.ArrayOf(count, elem)
+}

vendor/github.com/ugorji/go/codec/goversion_arrayof_lt_go15.go

@@ -0,0 +1,20 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build !go1.5
+// +build !go1.5
+
+package codec
+
+import (
+	"errors"
+	"reflect"
+)
+
+const reflectArrayOfSupported = false
+
+var errNoReflectArrayOf = errors.New("codec: reflect.ArrayOf unsupported by this go version")
+
+func reflectArrayOf(count int, elem reflect.Type) reflect.Type {
+	panic(errNoReflectArrayOf)
+}

vendor/github.com/ugorji/go/codec/goversion_fmt_time_gte_go15.go

@@ -0,0 +1,13 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build go1.5
+// +build go1.5
+
+package codec
+
+import "time"
+
+func fmtTime(t time.Time, fmt string, b []byte) []byte {
+	return t.AppendFormat(b, fmt)
+}

vendor/github.com/ugorji/go/codec/goversion_fmt_time_lt_go15.go

@@ -0,0 +1,16 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build !go1.5
+// +build !go1.5
+
+package codec
+
+import "time"
+
+func fmtTime(t time.Time, fmt string, b []byte) []byte {
+	s := t.Format(fmt)
+	b = b[:len(s)]
+	copy(b, s)
+	return b
+}

vendor/github.com/ugorji/go/codec/goversion_makemap_lt_go110.go

@@ -0,0 +1,13 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build !go1.10
+// +build !go1.10
+
+package codec
+
+import "reflect"
+
+func makeMapReflect(t reflect.Type, size int) reflect.Value {
+	return reflect.MakeMap(t)
+}

vendor/github.com/ugorji/go/codec/goversion_makemap_not_unsafe_gte_go110.go

@@ -0,0 +1,14 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build go1.10 && (safe || codec.safe || appengine)
+// +build go1.10
+// +build safe codec.safe appengine
+
+package codec
+
+import "reflect"
+
+func makeMapReflect(t reflect.Type, size int) reflect.Value {
+	return reflect.MakeMapWithSize(t, size)
+}

vendor/github.com/ugorji/go/codec/goversion_makemap_unsafe_gte_go110.go

@@ -0,0 +1,25 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build go1.10 && !safe && !codec.safe && !appengine
+// +build go1.10,!safe,!codec.safe,!appengine
+
+package codec
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+func makeMapReflect(typ reflect.Type, size int) (rv reflect.Value) {
+	t := (*unsafeIntf)(unsafe.Pointer(&typ)).ptr
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	urv.typ = t
+	urv.flag = uintptr(reflect.Map)
+	urv.ptr = makemap(t, size, nil)
+	return
+}
+
+//go:linkname makemap runtime.makemap
+//go:noescape
+func makemap(typ unsafe.Pointer, size int, h unsafe.Pointer) unsafe.Pointer

vendor/github.com/ugorji/go/codec/goversion_maprange_gte_go112.go

@@ -0,0 +1,41 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build go1.12 && (safe || codec.safe || appengine)
+// +build go1.12
+// +build safe codec.safe appengine
+
+package codec
+
+import "reflect"
+
+type mapIter struct {
+	t      *reflect.MapIter
+	m      reflect.Value
+	values bool
+}
+
+func (t *mapIter) Next() (r bool) {
+	return t.t.Next()
+}
+
+func (t *mapIter) Key() reflect.Value {
+	return t.t.Key()
+}
+
+func (t *mapIter) Value() (r reflect.Value) {
+	if t.values {
+		return t.t.Value()
+	}
+	return
+}
+
+func (t *mapIter) Done() {}
+
+func mapRange(t *mapIter, m, k, v reflect.Value, values bool) {
+	*t = mapIter{
+		m:      m,
+		t:      m.MapRange(),
+		values: values,
+	}
+}

vendor/github.com/ugorji/go/codec/goversion_maprange_lt_go112.go

@@ -0,0 +1,45 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build go1.7 && !go1.12 && (safe || codec.safe || appengine)
+// +build go1.7
+// +build !go1.12
+// +build safe codec.safe appengine
+
+package codec
+
+import "reflect"
+
+type mapIter struct {
+	m      reflect.Value
+	keys   []reflect.Value
+	j      int
+	values bool
+}
+
+func (t *mapIter) Next() (r bool) {
+	t.j++
+	return t.j < len(t.keys)
+}
+
+func (t *mapIter) Key() reflect.Value {
+	return t.keys[t.j]
+}
+
+func (t *mapIter) Value() (r reflect.Value) {
+	if t.values {
+		return t.m.MapIndex(t.keys[t.j])
+	}
+	return
+}
+
+func (t *mapIter) Done() {}
+
+func mapRange(t *mapIter, m, k, v reflect.Value, values bool) {
+	*t = mapIter{
+		m:      m,
+		keys:   m.MapKeys(),
+		values: values,
+		j:      -1,
+	}
+}

vendor/github.com/ugorji/go/codec/goversion_unexportedembeddedptr_gte_go110.go

@@ -0,0 +1,9 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build go1.10
+// +build go1.10
+
+package codec
+
+const allowSetUnexportedEmbeddedPtr = false

vendor/github.com/ugorji/go/codec/goversion_unexportedembeddedptr_lt_go110.go

@@ -0,0 +1,9 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build !go1.10
+// +build !go1.10
+
+package codec
+
+const allowSetUnexportedEmbeddedPtr = true

vendor/github.com/ugorji/go/codec/goversion_unsupported_lt_go14.go

@@ -0,0 +1,22 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build !go1.4
+// +build !go1.4
+
+package codec
+
+import "errors"
+
+// This codec package will only work for go1.4 and above.
+// This is for the following reasons:
+//   - go 1.4 was released in 2014
+//   - go runtime is written fully in go
+//   - interface only holds pointers
+//   - reflect.Value is stabilized as 3 words
+
+var errCodecSupportedOnlyFromGo14 = errors.New("codec: go 1.3 and below are not supported")
+
+func init() {
+	panic(errCodecSupportedOnlyFromGo14)
+}

vendor/github.com/ugorji/go/codec/goversion_vendor_eq_go15.go

@@ -0,0 +1,11 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build go1.5 && !go1.6
+// +build go1.5,!go1.6
+
+package codec
+
+import "os"
+
+var genCheckVendor = os.Getenv("GO15VENDOREXPERIMENT") == "1"

vendor/github.com/ugorji/go/codec/goversion_vendor_eq_go16.go

@@ -0,0 +1,11 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build go1.6 && !go1.7
+// +build go1.6,!go1.7
+
+package codec
+
+import "os"
+
+var genCheckVendor = os.Getenv("GO15VENDOREXPERIMENT") != "0"

vendor/github.com/ugorji/go/codec/goversion_vendor_gte_go17.go

@@ -0,0 +1,9 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build go1.7
+// +build go1.7
+
+package codec
+
+const genCheckVendor = true

vendor/github.com/ugorji/go/codec/goversion_vendor_lt_go15.go

@@ -0,0 +1,9 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build !go1.5
+// +build !go1.5
+
+package codec
+
+var genCheckVendor = false

vendor/github.com/ugorji/go/codec/helper_internal.go

@@ -0,0 +1,147 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+package codec
+
+// maxArrayLen is the size of uint, which determines
+// the maximum length of any array.
+const maxArrayLen = 1<<((32<<(^uint(0)>>63))-1) - 1
+
+// All non-std package dependencies live in this file,
+// so porting to different environment is easy (just update functions).
+
+func pruneSignExt(v []byte, pos bool) (n int) {
+	if len(v) < 2 {
+	} else if pos && v[0] == 0 {
+		for ; v[n] == 0 && n+1 < len(v) && (v[n+1]&(1<<7) == 0); n++ {
+		}
+	} else if !pos && v[0] == 0xff {
+		for ; v[n] == 0xff && n+1 < len(v) && (v[n+1]&(1<<7) != 0); n++ {
+		}
+	}
+	return
+}
+
+func halfFloatToFloatBits(h uint16) (f uint32) {
+	// retrofitted from:
+	// - OGRE (Object-Oriented Graphics Rendering Engine)
+	//   function: halfToFloatI https://www.ogre3d.org/docs/api/1.9/_ogre_bitwise_8h_source.html
+
+	s := uint32(h >> 15)
+	m := uint32(h & 0x03ff)
+	e := int32((h >> 10) & 0x1f)
+
+	if e == 0 {
+		if m == 0 { // plus or minus 0
+			return s << 31
+		}
+		// Denormalized number -- renormalize it
+		for (m & 0x0400) == 0 {
+			m <<= 1
+			e -= 1
+		}
+		e += 1
+		m &= ^uint32(0x0400)
+	} else if e == 31 {
+		if m == 0 { // Inf
+			return (s << 31) | 0x7f800000
+		}
+		return (s << 31) | 0x7f800000 | (m << 13) // NaN
+	}
+	e = e + (127 - 15)
+	m = m << 13
+	return (s << 31) | (uint32(e) << 23) | m
+}
+
+func floatToHalfFloatBits(i uint32) (h uint16) {
+	// retrofitted from:
+	// - OGRE (Object-Oriented Graphics Rendering Engine)
+	//   function: halfToFloatI https://www.ogre3d.org/docs/api/1.9/_ogre_bitwise_8h_source.html
+	// - http://www.java2s.com/example/java-utility-method/float-to/floattohalf-float-f-fae00.html
+	s := (i >> 16) & 0x8000
+	e := int32(((i >> 23) & 0xff) - (127 - 15))
+	m := i & 0x7fffff
+
+	var h32 uint32
+
+	if e <= 0 {
+		if e < -10 { // zero
+			h32 = s // track -0 vs +0
+		} else {
+			m = (m | 0x800000) >> uint32(1-e)
+			h32 = s | (m >> 13)
+		}
+	} else if e == 0xff-(127-15) {
+		if m == 0 { // Inf
+			h32 = s | 0x7c00
+		} else { // NAN
+			m >>= 13
+			var me uint32
+			if m == 0 {
+				me = 1
+			}
+			h32 = s | 0x7c00 | m | me
+		}
+	} else {
+		if e > 30 { // Overflow
+			h32 = s | 0x7c00
+		} else {
+			h32 = s | (uint32(e) << 10) | (m >> 13)
+		}
+	}
+	h = uint16(h32)
+	return
+}
+
+// growCap will return a new capacity for a slice, given the following:
+//   - oldCap: current capacity
+//   - unit: in-memory size of an element
+//   - num: number of elements to add
+func growCap(oldCap, unit, num uint) (newCap uint) {
+	// appendslice logic (if cap < 1024, *2, else *1.25):
+	//   leads to many copy calls, especially when copying bytes.
+	//   bytes.Buffer model (2*cap + n): much better for bytes.
+	// smarter way is to take the byte-size of the appended element(type) into account
+
+	// maintain 1 thresholds:
+	// t1: if cap <= t1, newcap = 2x
+	//     else          newcap = 1.5x
+	//
+	// t1 is always >= 1024.
+	// This means that, if unit size >= 16, then always do 2x or 1.5x (ie t1, t2, t3 are all same)
+	//
+	// With this, appending for bytes increase by:
+	//    100% up to 4K
+	//     50% beyond that
+
+	// unit can be 0 e.g. for struct{}{}; handle that appropriately
+	maxCap := num + (oldCap * 3 / 2)
+	if unit == 0 || maxCap > maxArrayLen || maxCap < oldCap { // handle wraparound, etc
+		return maxArrayLen
+	}
+
+	var t1 uint = 1024 // default thresholds for large values
+	if unit <= 4 {
+		t1 = 8 * 1024
+	} else if unit <= 16 {
+		t1 = 2 * 1024
+	}
+
+	newCap = 2 + num
+	if oldCap > 0 {
+		if oldCap <= t1 { // [0,t1]
+			newCap = num + (oldCap * 2)
+		} else { // (t1,infinity]
+			newCap = maxCap
+		}
+	}
+
+	// ensure newCap takes multiples of a cache line (size is a multiple of 64)
+	t1 = newCap * unit
+	if t2 := t1 % 64; t2 != 0 {
+		t1 += 64 - t2
+		newCap = t1 / unit
+	}
+
+	return
+}

vendor/github.com/ugorji/go/codec/helper_not_unsafe.go

@@ -0,0 +1,670 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build !go1.9 || safe || codec.safe || appengine
+// +build !go1.9 safe codec.safe appengine
+
+package codec
+
+import (
+	// "hash/adler32"
+	"math"
+	"reflect"
+	"sync/atomic"
+	"time"
+)
+
+// This file has safe variants of some helper functions.
+// MARKER: See helper_unsafe.go for the usage documentation.
+
+const safeMode = true
+
+const transientSizeMax = 0
+const transientValueHasStringSlice = true
+
+func stringView(v []byte) string {
+	return string(v)
+}
+
+func bytesView(v string) []byte {
+	return []byte(v)
+}
+
+func byteSliceSameData(v1 []byte, v2 []byte) bool {
+	return cap(v1) != 0 && cap(v2) != 0 && &(v1[:1][0]) == &(v2[:1][0])
+}
+
+func okBytes3(b []byte) (v [4]byte) {
+	copy(v[1:], b)
+	return
+}
+
+func okBytes4(b []byte) (v [4]byte) {
+	copy(v[:], b)
+	return
+}
+
+func okBytes8(b []byte) (v [8]byte) {
+	copy(v[:], b)
+	return
+}
+
+func isNil(v interface{}) (rv reflect.Value, isnil bool) {
+	rv = reflect.ValueOf(v)
+	if isnilBitset.isset(byte(rv.Kind())) {
+		isnil = rv.IsNil()
+	}
+	return
+}
+
+func eq4i(i0, i1 interface{}) bool {
+	return i0 == i1
+}
+
+func rv4iptr(i interface{}) reflect.Value { return reflect.ValueOf(i) }
+func rv4istr(i interface{}) reflect.Value { return reflect.ValueOf(i) }
+
+// func rv4i(i interface{}) reflect.Value { return reflect.ValueOf(i) }
+// func rv4iK(i interface{}, kind byte, isref bool) reflect.Value { return reflect.ValueOf(i) }
+
+func rv2i(rv reflect.Value) interface{} {
+	return rv.Interface()
+}
+
+func rvAddr(rv reflect.Value, ptrType reflect.Type) reflect.Value {
+	return rv.Addr()
+}
+
+func rvIsNil(rv reflect.Value) bool {
+	return rv.IsNil()
+}
+
+func rvSetSliceLen(rv reflect.Value, length int) {
+	rv.SetLen(length)
+}
+
+func rvZeroAddrK(t reflect.Type, k reflect.Kind) reflect.Value {
+	return reflect.New(t).Elem()
+}
+
+func rvZeroK(t reflect.Type, k reflect.Kind) reflect.Value {
+	return reflect.Zero(t)
+}
+
+func rvConvert(v reflect.Value, t reflect.Type) (rv reflect.Value) {
+	// Note that reflect.Value.Convert(...) will make a copy if it is addressable.
+	// Since we decode into the passed value, we must try to convert the addressable value..
+	if v.CanAddr() {
+		return v.Addr().Convert(reflect.PtrTo(t)).Elem()
+	}
+	return v.Convert(t)
+}
+
+func rt2id(rt reflect.Type) uintptr {
+	return reflect.ValueOf(rt).Pointer()
+}
+
+func i2rtid(i interface{}) uintptr {
+	return reflect.ValueOf(reflect.TypeOf(i)).Pointer()
+}
+
+// --------------------------
+
+func isEmptyValue(v reflect.Value, tinfos *TypeInfos, recursive bool) bool {
+	switch v.Kind() {
+	case reflect.Invalid:
+		return true
+	case reflect.Array, reflect.String:
+		return v.Len() == 0
+	case reflect.Map, reflect.Slice, reflect.Chan:
+		return v.IsNil() || v.Len() == 0
+	case reflect.Bool:
+		return !v.Bool()
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return v.Int() == 0
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return v.Uint() == 0
+	case reflect.Complex64, reflect.Complex128:
+		c := v.Complex()
+		return math.Float64bits(real(c)) == 0 && math.Float64bits(imag(c)) == 0
+	case reflect.Float32, reflect.Float64:
+		return v.Float() == 0
+	case reflect.Func, reflect.UnsafePointer:
+		return v.IsNil()
+	case reflect.Interface, reflect.Ptr:
+		isnil := v.IsNil()
+		if recursive && !isnil {
+			return isEmptyValue(v.Elem(), tinfos, recursive)
+		}
+		return isnil
+	case reflect.Struct:
+		return isEmptyStruct(v, tinfos, recursive)
+	}
+	return false
+}
+
+// isEmptyStruct is only called from isEmptyValue, and checks if a struct is empty:
+//    - does it implement IsZero() bool
+//    - is it comparable, and can i compare directly using ==
+//    - if checkStruct, then walk through the encodable fields
+//      and check if they are empty or not.
+func isEmptyStruct(v reflect.Value, tinfos *TypeInfos, recursive bool) bool {
+	// v is a struct kind - no need to check again.
+	// We only check isZero on a struct kind, to reduce the amount of times
+	// that we lookup the rtid and typeInfo for each type as we walk the tree.
+
+	vt := rvType(v)
+	rtid := rt2id(vt)
+	if tinfos == nil {
+		tinfos = defTypeInfos
+	}
+	ti := tinfos.get(rtid, vt)
+	if ti.rtid == timeTypId {
+		return rv2i(v).(time.Time).IsZero()
+	}
+	if ti.flagIsZeroer {
+		return rv2i(v).(isZeroer).IsZero()
+	}
+	if ti.flagIsZeroerPtr && v.CanAddr() {
+		return rv2i(v.Addr()).(isZeroer).IsZero()
+	}
+	if ti.flagIsCodecEmptyer {
+		return rv2i(v).(isCodecEmptyer).IsCodecEmpty()
+	}
+	if ti.flagIsCodecEmptyerPtr && v.CanAddr() {
+		return rv2i(v.Addr()).(isCodecEmptyer).IsCodecEmpty()
+	}
+	if ti.flagComparable {
+		return rv2i(v) == rv2i(rvZeroK(vt, reflect.Struct))
+	}
+	if !recursive {
+		return false
+	}
+	// We only care about what we can encode/decode,
+	// so that is what we use to check omitEmpty.
+	for _, si := range ti.sfi.source() {
+		sfv := si.path.field(v)
+		if sfv.IsValid() && !isEmptyValue(sfv, tinfos, recursive) {
+			return false
+		}
+	}
+	return true
+}
+
+// --------------------------
+
+type perTypeElem struct {
+	t    reflect.Type
+	rtid uintptr
+	zero reflect.Value
+	addr [2]reflect.Value
+}
+
+func (x *perTypeElem) get(index uint8) (v reflect.Value) {
+	v = x.addr[index%2]
+	if v.IsValid() {
+		v.Set(x.zero)
+	} else {
+		v = reflect.New(x.t).Elem()
+		x.addr[index%2] = v
+	}
+	return
+}
+
+type perType struct {
+	v []perTypeElem
+}
+
+type decPerType struct {
+	perType
+}
+
+type encPerType struct {
+	perType
+}
+
+func (x *perType) elem(t reflect.Type) *perTypeElem {
+	rtid := rt2id(t)
+	var h, i uint
+	var j = uint(len(x.v))
+LOOP:
+	if i < j {
+		h = (i + j) >> 1 // avoid overflow when computing h // h = i + (j-i)/2
+		if x.v[h].rtid < rtid {
+			i = h + 1
+		} else {
+			j = h
+		}
+		goto LOOP
+	}
+	if i < uint(len(x.v)) {
+		if x.v[i].rtid != rtid {
+			x.v = append(x.v, perTypeElem{})
+			copy(x.v[i+1:], x.v[i:])
+			x.v[i] = perTypeElem{t: t, rtid: rtid, zero: reflect.Zero(t)}
+		}
+	} else {
+		x.v = append(x.v, perTypeElem{t: t, rtid: rtid, zero: reflect.Zero(t)})
+	}
+	return &x.v[i]
+}
+
+func (x *perType) TransientAddrK(t reflect.Type, k reflect.Kind) (rv reflect.Value) {
+	return x.elem(t).get(0)
+}
+
+func (x *perType) TransientAddr2K(t reflect.Type, k reflect.Kind) (rv reflect.Value) {
+	return x.elem(t).get(1)
+}
+
+func (x *perType) AddressableRO(v reflect.Value) (rv reflect.Value) {
+	rv = x.elem(v.Type()).get(0)
+	rvSetDirect(rv, v)
+	return
+}
+
+// --------------------------
+type structFieldInfos struct {
+	c []*structFieldInfo
+	s []*structFieldInfo
+}
+
+func (x *structFieldInfos) load(source, sorted []*structFieldInfo) {
+	x.c = source
+	x.s = sorted
+}
+
+func (x *structFieldInfos) sorted() (v []*structFieldInfo) { return x.s }
+func (x *structFieldInfos) source() (v []*structFieldInfo) { return x.c }
+
+type atomicClsErr struct {
+	v atomic.Value
+}
+
+func (x *atomicClsErr) load() (e clsErr) {
+	if i := x.v.Load(); i != nil {
+		e = i.(clsErr)
+	}
+	return
+}
+
+func (x *atomicClsErr) store(p clsErr) {
+	x.v.Store(p)
+}
+
+// --------------------------
+type atomicTypeInfoSlice struct {
+	v atomic.Value
+}
+
+func (x *atomicTypeInfoSlice) load() (e []rtid2ti) {
+	if i := x.v.Load(); i != nil {
+		e = i.([]rtid2ti)
+	}
+	return
+}
+
+func (x *atomicTypeInfoSlice) store(p []rtid2ti) {
+	x.v.Store(p)
+}
+
+// --------------------------
+type atomicRtidFnSlice struct {
+	v atomic.Value
+}
+
+func (x *atomicRtidFnSlice) load() (e []codecRtidFn) {
+	if i := x.v.Load(); i != nil {
+		e = i.([]codecRtidFn)
+	}
+	return
+}
+
+func (x *atomicRtidFnSlice) store(p []codecRtidFn) {
+	x.v.Store(p)
+}
+
+// --------------------------
+func (n *fauxUnion) ru() reflect.Value {
+	return reflect.ValueOf(&n.u).Elem()
+}
+func (n *fauxUnion) ri() reflect.Value {
+	return reflect.ValueOf(&n.i).Elem()
+}
+func (n *fauxUnion) rf() reflect.Value {
+	return reflect.ValueOf(&n.f).Elem()
+}
+func (n *fauxUnion) rl() reflect.Value {
+	return reflect.ValueOf(&n.l).Elem()
+}
+func (n *fauxUnion) rs() reflect.Value {
+	return reflect.ValueOf(&n.s).Elem()
+}
+func (n *fauxUnion) rt() reflect.Value {
+	return reflect.ValueOf(&n.t).Elem()
+}
+func (n *fauxUnion) rb() reflect.Value {
+	return reflect.ValueOf(&n.b).Elem()
+}
+
+// --------------------------
+func rvSetBytes(rv reflect.Value, v []byte) {
+	rv.SetBytes(v)
+}
+
+func rvSetString(rv reflect.Value, v string) {
+	rv.SetString(v)
+}
+
+func rvSetBool(rv reflect.Value, v bool) {
+	rv.SetBool(v)
+}
+
+func rvSetTime(rv reflect.Value, v time.Time) {
+	rv.Set(reflect.ValueOf(v))
+}
+
+func rvSetFloat32(rv reflect.Value, v float32) {
+	rv.SetFloat(float64(v))
+}
+
+func rvSetFloat64(rv reflect.Value, v float64) {
+	rv.SetFloat(v)
+}
+
+func rvSetComplex64(rv reflect.Value, v complex64) {
+	rv.SetComplex(complex128(v))
+}
+
+func rvSetComplex128(rv reflect.Value, v complex128) {
+	rv.SetComplex(v)
+}
+
+func rvSetInt(rv reflect.Value, v int) {
+	rv.SetInt(int64(v))
+}
+
+func rvSetInt8(rv reflect.Value, v int8) {
+	rv.SetInt(int64(v))
+}
+
+func rvSetInt16(rv reflect.Value, v int16) {
+	rv.SetInt(int64(v))
+}
+
+func rvSetInt32(rv reflect.Value, v int32) {
+	rv.SetInt(int64(v))
+}
+
+func rvSetInt64(rv reflect.Value, v int64) {
+	rv.SetInt(v)
+}
+
+func rvSetUint(rv reflect.Value, v uint) {
+	rv.SetUint(uint64(v))
+}
+
+func rvSetUintptr(rv reflect.Value, v uintptr) {
+	rv.SetUint(uint64(v))
+}
+
+func rvSetUint8(rv reflect.Value, v uint8) {
+	rv.SetUint(uint64(v))
+}
+
+func rvSetUint16(rv reflect.Value, v uint16) {
+	rv.SetUint(uint64(v))
+}
+
+func rvSetUint32(rv reflect.Value, v uint32) {
+	rv.SetUint(uint64(v))
+}
+
+func rvSetUint64(rv reflect.Value, v uint64) {
+	rv.SetUint(v)
+}
+
+// ----------------
+
+func rvSetDirect(rv reflect.Value, v reflect.Value) {
+	rv.Set(v)
+}
+
+func rvSetDirectZero(rv reflect.Value) {
+	rv.Set(reflect.Zero(rv.Type()))
+}
+
+// func rvSet(rv reflect.Value, v reflect.Value) {
+// 	rv.Set(v)
+// }
+
+func rvSetIntf(rv reflect.Value, v reflect.Value) {
+	rv.Set(v)
+}
+
+func rvSetZero(rv reflect.Value) {
+	rv.Set(reflect.Zero(rv.Type()))
+}
+
+func rvSlice(rv reflect.Value, length int) reflect.Value {
+	return rv.Slice(0, length)
+}
+
+func rvMakeSlice(rv reflect.Value, ti *typeInfo, xlen, xcap int) (v reflect.Value, set bool) {
+	v = reflect.MakeSlice(ti.rt, xlen, xcap)
+	if rv.Len() > 0 {
+		reflect.Copy(v, rv)
+	}
+	return
+}
+
+func rvGrowSlice(rv reflect.Value, ti *typeInfo, cap, incr int) (v reflect.Value, newcap int, set bool) {
+	newcap = int(growCap(uint(cap), uint(ti.elemsize), uint(incr)))
+	v = reflect.MakeSlice(ti.rt, newcap, newcap)
+	if rv.Len() > 0 {
+		reflect.Copy(v, rv)
+	}
+	return
+}
+
+// ----------------
+
+func rvSliceIndex(rv reflect.Value, i int, ti *typeInfo) reflect.Value {
+	return rv.Index(i)
+}
+
+func rvArrayIndex(rv reflect.Value, i int, ti *typeInfo) reflect.Value {
+	return rv.Index(i)
+}
+
+func rvSliceZeroCap(t reflect.Type) (v reflect.Value) {
+	return reflect.MakeSlice(t, 0, 0)
+}
+
+func rvLenSlice(rv reflect.Value) int {
+	return rv.Len()
+}
+
+func rvCapSlice(rv reflect.Value) int {
+	return rv.Cap()
+}
+
+func rvGetArrayBytes(rv reflect.Value, scratch []byte) (bs []byte) {
+	l := rv.Len()
+	if scratch == nil || rv.CanAddr() {
+		return rv.Slice(0, l).Bytes()
+	}
+
+	if l <= cap(scratch) {
+		bs = scratch[:l]
+	} else {
+		bs = make([]byte, l)
+	}
+	reflect.Copy(reflect.ValueOf(bs), rv)
+	return
+}
+
+func rvGetArray4Slice(rv reflect.Value) (v reflect.Value) {
+	v = rvZeroAddrK(reflectArrayOf(rvLenSlice(rv), rvType(rv).Elem()), reflect.Array)
+	reflect.Copy(v, rv)
+	return
+}
+
+func rvGetSlice4Array(rv reflect.Value, v interface{}) {
+	// v is a pointer to a slice to be populated
+
+	// rv.Slice fails if address is not addressable, which can occur during encoding.
+	// Consequently, check if non-addressable, and if so, make new slice and copy into it first.
+	// MARKER: this *may* cause allocation if non-addressable, unfortunately.
+
+	rve := reflect.ValueOf(v).Elem()
+	l := rv.Len()
+	if rv.CanAddr() {
+		rve.Set(rv.Slice(0, l))
+	} else {
+		rvs := reflect.MakeSlice(rve.Type(), l, l)
+		reflect.Copy(rvs, rv)
+		rve.Set(rvs)
+	}
+	// reflect.ValueOf(v).Elem().Set(rv.Slice(0, rv.Len()))
+}
+
+func rvCopySlice(dest, src reflect.Value, _ reflect.Type) {
+	reflect.Copy(dest, src)
+}
+
+// ------------
+
+func rvGetBool(rv reflect.Value) bool {
+	return rv.Bool()
+}
+
+func rvGetBytes(rv reflect.Value) []byte {
+	return rv.Bytes()
+}
+
+func rvGetTime(rv reflect.Value) time.Time {
+	return rv2i(rv).(time.Time)
+}
+
+func rvGetString(rv reflect.Value) string {
+	return rv.String()
+}
+
+func rvGetFloat64(rv reflect.Value) float64 {
+	return rv.Float()
+}
+
+func rvGetFloat32(rv reflect.Value) float32 {
+	return float32(rv.Float())
+}
+
+func rvGetComplex64(rv reflect.Value) complex64 {
+	return complex64(rv.Complex())
+}
+
+func rvGetComplex128(rv reflect.Value) complex128 {
+	return rv.Complex()
+}
+
+func rvGetInt(rv reflect.Value) int {
+	return int(rv.Int())
+}
+
+func rvGetInt8(rv reflect.Value) int8 {
+	return int8(rv.Int())
+}
+
+func rvGetInt16(rv reflect.Value) int16 {
+	return int16(rv.Int())
+}
+
+func rvGetInt32(rv reflect.Value) int32 {
+	return int32(rv.Int())
+}
+
+func rvGetInt64(rv reflect.Value) int64 {
+	return rv.Int()
+}
+
+func rvGetUint(rv reflect.Value) uint {
+	return uint(rv.Uint())
+}
+
+func rvGetUint8(rv reflect.Value) uint8 {
+	return uint8(rv.Uint())
+}
+
+func rvGetUint16(rv reflect.Value) uint16 {
+	return uint16(rv.Uint())
+}
+
+func rvGetUint32(rv reflect.Value) uint32 {
+	return uint32(rv.Uint())
+}
+
+func rvGetUint64(rv reflect.Value) uint64 {
+	return rv.Uint()
+}
+
+func rvGetUintptr(rv reflect.Value) uintptr {
+	return uintptr(rv.Uint())
+}
+
+func rvLenMap(rv reflect.Value) int {
+	return rv.Len()
+}
+
+// func rvLenArray(rv reflect.Value) int {	return rv.Len() }
+
+// ------------ map range and map indexing ----------
+
+func mapStoresElemIndirect(elemsize uintptr) bool { return false }
+
+func mapSet(m, k, v reflect.Value, keyFastKind mapKeyFastKind, _, _ bool) {
+	m.SetMapIndex(k, v)
+}
+
+func mapGet(m, k, v reflect.Value, keyFastKind mapKeyFastKind, _, _ bool) (vv reflect.Value) {
+	return m.MapIndex(k)
+}
+
+// func mapDelete(m, k reflect.Value) {
+// 	m.SetMapIndex(k, reflect.Value{})
+// }
+
+func mapAddrLoopvarRV(t reflect.Type, k reflect.Kind) (r reflect.Value) {
+	return // reflect.New(t).Elem()
+}
+
+// ---------- ENCODER optimized ---------------
+
+func (e *Encoder) jsondriver() *jsonEncDriver {
+	return e.e.(*jsonEncDriver)
+}
+
+// ---------- DECODER optimized ---------------
+
+func (d *Decoder) checkBreak() bool {
+	return d.d.CheckBreak()
+}
+
+func (d *Decoder) jsondriver() *jsonDecDriver {
+	return d.d.(*jsonDecDriver)
+}
+
+func (d *Decoder) stringZC(v []byte) (s string) {
+	return d.string(v)
+}
+
+func (d *Decoder) mapKeyString(callFnRvk *bool, kstrbs, kstr2bs *[]byte) string {
+	return d.string(*kstr2bs)
+}
+
+// ---------- structFieldInfo optimized ---------------
+
+func (n *structFieldInfoPathNode) rvField(v reflect.Value) reflect.Value {
+	return v.Field(int(n.index))
+}
+
+// ---------- others ---------------

vendor/github.com/ugorji/go/codec/helper_not_unsafe_not_gc.go

@@ -0,0 +1,19 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build !go1.9 || safe || codec.safe || appengine || !gc
+// +build !go1.9 safe codec.safe appengine !gc
+
+package codec
+
+import "reflect"
+
+// This files contains safe versions of the code where the unsafe versions are not supported
+// in either gccgo or gollvm.
+//
+// - rvType:
+//   reflect.toType is not supported in gccgo, gollvm.
+
+func rvType(rv reflect.Value) reflect.Type {
+	return rv.Type()
+}

vendor/github.com/ugorji/go/codec/helper_unsafe_compiler_gc.go

@@ -0,0 +1,171 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build !safe && !codec.safe && !appengine && go1.9 && gc
+// +build !safe,!codec.safe,!appengine,go1.9,gc
+
+package codec
+
+import (
+	"reflect"
+	_ "runtime" // needed for go linkname(s)
+	"unsafe"
+)
+
+// keep in sync with
+//    $GOROOT/src/cmd/compile/internal/gc/reflect.go: MAXKEYSIZE, MAXELEMSIZE
+//    $GOROOT/src/runtime/map.go: maxKeySize, maxElemSize
+//    $GOROOT/src/reflect/type.go: maxKeySize, maxElemSize
+//
+// We use these to determine whether the type is stored indirectly in the map or not.
+const (
+	// mapMaxKeySize  = 128
+	mapMaxElemSize = 128
+)
+
+func unsafeGrowslice(typ unsafe.Pointer, old unsafeSlice, cap, incr int) (v unsafeSlice) {
+	return growslice(typ, old, cap+incr)
+}
+
+func rvType(rv reflect.Value) reflect.Type {
+	return rvPtrToType(((*unsafeReflectValue)(unsafe.Pointer(&rv))).typ) // rv.Type()
+}
+
+// mapStoresElemIndirect tells if the element type is stored indirectly in the map.
+//
+// This is used to determine valIsIndirect which is passed into mapSet/mapGet calls.
+//
+// If valIsIndirect doesn't matter, then just return false and ignore the value
+// passed in mapGet/mapSet calls
+func mapStoresElemIndirect(elemsize uintptr) bool {
+	return elemsize > mapMaxElemSize
+}
+
+func mapSet(m, k, v reflect.Value, keyFastKind mapKeyFastKind, valIsIndirect, valIsRef bool) {
+	var urv = (*unsafeReflectValue)(unsafe.Pointer(&k))
+	var kptr = unsafeMapKVPtr(urv)
+	urv = (*unsafeReflectValue)(unsafe.Pointer(&v))
+	var vtyp = urv.typ
+	var vptr = unsafeMapKVPtr(urv)
+
+	urv = (*unsafeReflectValue)(unsafe.Pointer(&m))
+	mptr := rvRefPtr(urv)
+
+	var vvptr unsafe.Pointer
+
+	// mapassign_fastXXX don't take indirect into account.
+	// It was hard to infer what makes it work all the time.
+	// Sometimes, we got vvptr == nil when we dereferenced vvptr (if valIsIndirect).
+	// Consequently, only use fastXXX functions if !valIsIndirect
+
+	if valIsIndirect {
+		vvptr = mapassign(urv.typ, mptr, kptr)
+		typedmemmove(vtyp, vvptr, vptr)
+		// reflect_mapassign(urv.typ, mptr, kptr, vptr)
+		return
+	}
+
+	switch keyFastKind {
+	case mapKeyFastKind32:
+		vvptr = mapassign_fast32(urv.typ, mptr, *(*uint32)(kptr))
+	case mapKeyFastKind32ptr:
+		vvptr = mapassign_fast32ptr(urv.typ, mptr, *(*unsafe.Pointer)(kptr))
+	case mapKeyFastKind64:
+		vvptr = mapassign_fast64(urv.typ, mptr, *(*uint64)(kptr))
+	case mapKeyFastKind64ptr:
+		vvptr = mapassign_fast64ptr(urv.typ, mptr, *(*unsafe.Pointer)(kptr))
+	case mapKeyFastKindStr:
+		vvptr = mapassign_faststr(urv.typ, mptr, *(*string)(kptr))
+	default:
+		vvptr = mapassign(urv.typ, mptr, kptr)
+	}
+
+	// if keyFastKind != 0 && valIsIndirect {
+	// 	vvptr = *(*unsafe.Pointer)(vvptr)
+	// }
+
+	typedmemmove(vtyp, vvptr, vptr)
+}
+
+func mapGet(m, k, v reflect.Value, keyFastKind mapKeyFastKind, valIsIndirect, valIsRef bool) (_ reflect.Value) {
+	var urv = (*unsafeReflectValue)(unsafe.Pointer(&k))
+	var kptr = unsafeMapKVPtr(urv)
+	urv = (*unsafeReflectValue)(unsafe.Pointer(&m))
+	mptr := rvRefPtr(urv)
+
+	var vvptr unsafe.Pointer
+	var ok bool
+
+	// Note that mapaccess2_fastXXX functions do not check if the value needs to be copied.
+	// if they do, we should dereference the pointer and return that
+
+	switch keyFastKind {
+	case mapKeyFastKind32, mapKeyFastKind32ptr:
+		vvptr, ok = mapaccess2_fast32(urv.typ, mptr, *(*uint32)(kptr))
+	case mapKeyFastKind64, mapKeyFastKind64ptr:
+		vvptr, ok = mapaccess2_fast64(urv.typ, mptr, *(*uint64)(kptr))
+	case mapKeyFastKindStr:
+		vvptr, ok = mapaccess2_faststr(urv.typ, mptr, *(*string)(kptr))
+	default:
+		vvptr, ok = mapaccess2(urv.typ, mptr, kptr)
+	}
+
+	if !ok {
+		return
+	}
+
+	urv = (*unsafeReflectValue)(unsafe.Pointer(&v))
+
+	if keyFastKind != 0 && valIsIndirect {
+		urv.ptr = *(*unsafe.Pointer)(vvptr)
+	} else if helperUnsafeDirectAssignMapEntry || valIsRef {
+		urv.ptr = vvptr
+	} else {
+		typedmemmove(urv.typ, urv.ptr, vvptr)
+	}
+
+	return v
+}
+
+//go:linkname unsafeZeroArr runtime.zeroVal
+var unsafeZeroArr [1024]byte
+
+//go:linkname rvPtrToType reflect.toType
+//go:noescape
+func rvPtrToType(typ unsafe.Pointer) reflect.Type
+
+//go:linkname growslice runtime.growslice
+//go:noescape
+func growslice(typ unsafe.Pointer, old unsafeSlice, cap int) unsafeSlice
+
+//go:linkname mapassign_fast32 runtime.mapassign_fast32
+//go:noescape
+func mapassign_fast32(typ unsafe.Pointer, m unsafe.Pointer, key uint32) unsafe.Pointer
+
+//go:linkname mapassign_fast32ptr runtime.mapassign_fast32ptr
+//go:noescape
+func mapassign_fast32ptr(typ unsafe.Pointer, m unsafe.Pointer, key unsafe.Pointer) unsafe.Pointer
+
+//go:linkname mapassign_fast64 runtime.mapassign_fast64
+//go:noescape
+func mapassign_fast64(typ unsafe.Pointer, m unsafe.Pointer, key uint64) unsafe.Pointer
+
+//go:linkname mapassign_fast64ptr runtime.mapassign_fast64ptr
+//go:noescape
+func mapassign_fast64ptr(typ unsafe.Pointer, m unsafe.Pointer, key unsafe.Pointer) unsafe.Pointer
+
+//go:linkname mapassign_faststr runtime.mapassign_faststr
+//go:noescape
+func mapassign_faststr(typ unsafe.Pointer, m unsafe.Pointer, s string) unsafe.Pointer
+
+//go:linkname mapaccess2_fast32 runtime.mapaccess2_fast32
+//go:noescape
+func mapaccess2_fast32(typ unsafe.Pointer, m unsafe.Pointer, key uint32) (val unsafe.Pointer, ok bool)
+
+//go:linkname mapaccess2_fast64 runtime.mapaccess2_fast64
+//go:noescape
+func mapaccess2_fast64(typ unsafe.Pointer, m unsafe.Pointer, key uint64) (val unsafe.Pointer, ok bool)
+
+//go:linkname mapaccess2_faststr runtime.mapaccess2_faststr
+//go:noescape
+func mapaccess2_faststr(typ unsafe.Pointer, m unsafe.Pointer, key string) (val unsafe.Pointer, ok bool)

vendor/github.com/ugorji/go/codec/helper_unsafe_compiler_not_gc.go

@@ -0,0 +1,80 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build !safe && !codec.safe && !appengine && go1.9 && !gc
+// +build !safe,!codec.safe,!appengine,go1.9,!gc
+
+package codec
+
+import (
+	"reflect"
+	_ "runtime" // needed for go linkname(s)
+	"unsafe"
+)
+
+var unsafeZeroArr [1024]byte
+
+// runtime.growslice does not work with gccgo, failing with "growslice: cap out of range" error.
+// consequently, we just call newarray followed by typedslicecopy directly.
+
+func unsafeGrowslice(typ unsafe.Pointer, old unsafeSlice, cap, incr int) (v unsafeSlice) {
+	size := rtsize2(typ)
+	if size == 0 {
+		return unsafeSlice{unsafe.Pointer(&unsafeZeroArr[0]), old.Len, cap + incr}
+	}
+	newcap := int(growCap(uint(cap), uint(size), uint(incr)))
+	v = unsafeSlice{Data: newarray(typ, newcap), Len: old.Len, Cap: newcap}
+	if old.Len > 0 {
+		typedslicecopy(typ, v, old)
+	}
+	// memmove(v.Data, old.Data, size*uintptr(old.Len))
+	return
+}
+
+// func unsafeNew(t reflect.Type, typ unsafe.Pointer) unsafe.Pointer {
+// 	rv := reflect.New(t)
+// 	return ((*unsafeReflectValue)(unsafe.Pointer(&rv))).ptr
+// }
+
+// runtime.{mapassign_fastXXX, mapaccess2_fastXXX} are not supported in gollvm,
+// failing with "error: undefined reference" error.
+// so we just use runtime.{mapassign, mapaccess2} directly
+
+func mapStoresElemIndirect(elemsize uintptr) bool { return false }
+
+func mapSet(m, k, v reflect.Value, _ mapKeyFastKind, _, valIsRef bool) {
+	var urv = (*unsafeReflectValue)(unsafe.Pointer(&k))
+	var kptr = unsafeMapKVPtr(urv)
+	urv = (*unsafeReflectValue)(unsafe.Pointer(&v))
+	var vtyp = urv.typ
+	var vptr = unsafeMapKVPtr(urv)
+
+	urv = (*unsafeReflectValue)(unsafe.Pointer(&m))
+	mptr := rvRefPtr(urv)
+
+	vvptr := mapassign(urv.typ, mptr, kptr)
+	typedmemmove(vtyp, vvptr, vptr)
+}
+
+func mapGet(m, k, v reflect.Value, _ mapKeyFastKind, _, valIsRef bool) (_ reflect.Value) {
+	var urv = (*unsafeReflectValue)(unsafe.Pointer(&k))
+	var kptr = unsafeMapKVPtr(urv)
+	urv = (*unsafeReflectValue)(unsafe.Pointer(&m))
+	mptr := rvRefPtr(urv)
+
+	vvptr, ok := mapaccess2(urv.typ, mptr, kptr)
+
+	if !ok {
+		return
+	}
+
+	urv = (*unsafeReflectValue)(unsafe.Pointer(&v))
+
+	if helperUnsafeDirectAssignMapEntry || valIsRef {
+		urv.ptr = vvptr
+	} else {
+		typedmemmove(urv.typ, urv.ptr, vvptr)
+	}
+
+	return v
+}

vendor/github.com/ugorji/go/codec/mammoth-test.go.tmpl

@@ -0,0 +1,235 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build !codec.notmammoth
+// +build codec.notmammoth
+
+// Code generated from mammoth-test.go.tmpl - DO NOT EDIT.
+
+package codec
+
+import "testing"
+import "fmt"
+import "reflect"
+
+// TestMammoth has all the different paths optimized in fast-path
+// It has all the primitives, slices and maps.
+// 
+// For each of those types, it has a pointer and a non-pointer field.
+
+func init() { _ = fmt.Printf } // so we can include fmt as needed
+
+type TestMammoth struct {
+
+{{range .Values }}{{if .Primitive -}}
+{{ .MethodNamePfx "F" true }} {{ .Primitive }}
+{{ .MethodNamePfx "Fptr" true }} *{{ .Primitive }}
+{{end}}{{end}}
+
+{{range .Values }}{{if not .Primitive }}{{if not .MapKey -}}
+{{ .MethodNamePfx "F" false }} []{{ .Elem }}
+{{ .MethodNamePfx "Fptr" false }} *[]{{ .Elem }}
+{{ .MethodNamePfx "Farr4" false }} [4]{{ .Elem }}
+{{end}}{{end}}{{end}}
+
+{{range .Values }}{{if not .Primitive }}{{if .MapKey -}}
+{{ .MethodNamePfx "F" false }} map[{{ .MapKey }}]{{ .Elem }}
+{{ .MethodNamePfx "Fptr" false }} *map[{{ .MapKey }}]{{ .Elem }}
+{{end}}{{end}}{{end}}
+
+}
+
+{{range .Values }}{{if not .Primitive }}{{if not .MapKey -}}
+type {{ .MethodNamePfx "typMbs" false }} []{{ .Elem }}
+func (_ {{ .MethodNamePfx "typMbs" false }}) MapBySlice() { }
+{{end}}{{end}}{{end}}
+
+{{range .Values }}{{if not .Primitive }}{{if .MapKey -}}
+type {{ .MethodNamePfx "typMap" false }} map[{{ .MapKey }}]{{ .Elem }}
+{{end}}{{end}}{{end}}
+
+func __doTestMammothSlices(t *testing.T, h Handle) {
+{{range $i, $e := .Values }}{{if not .Primitive }}{{if not .MapKey -}}
+    var v{{$i}}va [8]{{ .Elem }}
+    for _, v := range [][]{{ .Elem }}{ nil, {}, { {{ nonzerocmd .Elem }}, {{ zerocmd .Elem }}, {{ zerocmd .Elem }}, {{ nonzerocmd .Elem }} } } {
+	{{/*
+    // fmt.Printf(">>>> running mammoth slice v{{$i}}: %v\n", v)
+    //   - encode value to some []byte
+    //   - decode into a length-wise-equal []byte
+    //   - check if equal to initial slice
+    //   - encode ptr to the value
+    //   - check if encode bytes are same
+    //   - decode into ptrs to: nil, then 1-elem slice, equal-length, then large len slice
+    //   - decode into non-addressable slice of equal length, then larger len 
+    //   - for each decode, compare elem-by-elem to the original slice
+    //   - 
+    //   - rinse and repeat for a MapBySlice version
+    //   - 
+    */ -}}
+    var v{{$i}}v1, v{{$i}}v2 []{{ .Elem }}
+    var bs{{$i}} []byte
+	v{{$i}}v1 = v
+	bs{{$i}} = testMarshalErr(v{{$i}}v1, h, t, "enc-slice-v{{$i}}")
+	if v == nil {
+	v{{$i}}v2 = make([]{{ .Elem }}, 2)
+	testUnmarshalErr(v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}")
+	testDeepEqualErr(v{{$i}}v2[0], v{{$i}}v2[1], t, "equal-slice-v{{$i}}") // should not change
+	testDeepEqualErr(len(v{{$i}}v2), 2, t, "equal-slice-v{{$i}}") // should not change
+	v{{$i}}v2 = make([]{{ .Elem }}, 2)
+	testUnmarshalErr(reflect.ValueOf(v{{$i}}v2), bs{{$i}}, h, t, "dec-slice-v{{$i}}-noaddr") // non-addressable value
+	testDeepEqualErr(v{{$i}}v2[0], v{{$i}}v2[1], t, "equal-slice-v{{$i}}-noaddr") // should not change
+	testDeepEqualErr(len(v{{$i}}v2), 2, t, "equal-slice-v{{$i}}") // should not change
+	} else {
+	v{{$i}}v2 = make([]{{ .Elem }}, len(v))
+	testUnmarshalErr(v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}")
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}")
+	v{{$i}}v2 = make([]{{ .Elem }}, len(v))
+	testUnmarshalErr(reflect.ValueOf(v{{$i}}v2), bs{{$i}}, h, t, "dec-slice-v{{$i}}-noaddr") // non-addressable value
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-noaddr")
+	}
+	testReleaseBytes(bs{{$i}})
+	// ...
+	bs{{$i}} = testMarshalErr(&v{{$i}}v1, h, t, "enc-slice-v{{$i}}-p")
+	v{{$i}}v2 = nil
+	testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}-p")
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-p")
+	v{{$i}}va = [8]{{ .Elem }}{} // clear the array
+	testUnmarshalErr(&v{{$i}}va, bs{{$i}}, h, t, "dec-array-v{{$i}}-p-1")
+	if v{{$i}}v1 == nil && v{{$i}}v2 == nil { v{{$i}}v2 = []{{ .Elem }}{} } // so we can compare to zero len slice below
+	testDeepEqualErr(v{{$i}}va[:len(v{{$i}}v2)], v{{$i}}v2, t, "equal-array-v{{$i}}-p-1")
+	v{{$i}}va = [8]{{ .Elem }}{} // clear the array		
+	v{{$i}}v2 = v{{$i}}va[:1:1]
+	testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-1")
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-p-1")
+	v{{$i}}va = [8]{{ .Elem }}{} // clear the array
+	v{{$i}}v2 = v{{$i}}va[:len(v{{$i}}v1):len(v{{$i}}v1)]
+	testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-len")
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-p-len")
+	v{{$i}}va = [8]{{ .Elem }}{} // clear the array
+	v{{$i}}v2 = v{{$i}}va[:]
+	testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-cap")
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-p-cap")
+	if len(v{{$i}}v1) > 1 {
+	v{{$i}}va = [8]{{ .Elem }}{} // clear the array
+	testUnmarshalErr((&v{{$i}}va)[:len(v{{$i}}v1)], bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-len-noaddr")
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}va[:len(v{{$i}}v1)], t, "equal-slice-v{{$i}}-p-len-noaddr")
+	v{{$i}}va = [8]{{ .Elem }}{} // clear the array
+	testUnmarshalErr((&v{{$i}}va)[:], bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-cap-noaddr")
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}va[:len(v{{$i}}v1)], t, "equal-slice-v{{$i}}-p-cap-noaddr")
+    }
+	testReleaseBytes(bs{{$i}})
+    // ...
+    var v{{$i}}v3, v{{$i}}v4 {{ .MethodNamePfx "typMbs" false }}
+	v{{$i}}v2 = nil
+    if v != nil { v{{$i}}v2 = make([]{{ .Elem }}, len(v)) }
+    v{{$i}}v3 = {{ .MethodNamePfx "typMbs" false }}(v{{$i}}v1)
+    v{{$i}}v4 = {{ .MethodNamePfx "typMbs" false }}(v{{$i}}v2)
+    if v != nil {
+    bs{{$i}} = testMarshalErr(v{{$i}}v3, h, t, "enc-slice-v{{$i}}-custom")
+    testUnmarshalErr(v{{$i}}v4, bs{{$i}}, h, t, "dec-slice-v{{$i}}-custom")
+    testDeepEqualErr(v{{$i}}v3, v{{$i}}v4, t, "equal-slice-v{{$i}}-custom")
+	testReleaseBytes(bs{{$i}})
+    }
+    bs{{$i}} = testMarshalErr(&v{{$i}}v3, h, t, "enc-slice-v{{$i}}-custom-p")
+    v{{$i}}v2 = nil
+    v{{$i}}v4 = {{ .MethodNamePfx "typMbs" false }}(v{{$i}}v2)
+    testUnmarshalErr(&v{{$i}}v4, bs{{$i}}, h, t, "dec-slice-v{{$i}}-custom-p")
+    testDeepEqualErr(v{{$i}}v3, v{{$i}}v4, t, "equal-slice-v{{$i}}-custom-p")
+	testReleaseBytes(bs{{$i}})
+    }
+{{end}}{{end}}{{end}}
+}
+
+func __doTestMammothMaps(t *testing.T, h Handle) {
+{{range $i, $e := .Values }}{{if not .Primitive }}{{if .MapKey -}}
+    for _, v := range []map[{{ .MapKey }}]{{ .Elem }}{ nil, {}, { {{ nonzerocmd .MapKey }}:{{ zerocmd .Elem }} {{if ne "bool" .MapKey}}, {{ nonzerocmd .MapKey }}:{{ nonzerocmd .Elem }} {{end}} } } {
+    // fmt.Printf(">>>> running mammoth map v{{$i}}: %v\n", v)
+    var v{{$i}}v1, v{{$i}}v2 map[{{ .MapKey }}]{{ .Elem }}
+    var bs{{$i}} []byte
+	v{{$i}}v1 = v
+	bs{{$i}} = testMarshalErr(v{{$i}}v1, h, t, "enc-map-v{{$i}}")
+    if v != nil {
+	if v == nil { v{{$i}}v2 = nil } else { v{{$i}}v2 = make(map[{{ .MapKey }}]{{ .Elem }}, len(v)) } // reset map
+	testUnmarshalErr(v{{$i}}v2, bs{{$i}}, h, t, "dec-map-v{{$i}}")
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-map-v{{$i}}")
+	if v == nil { v{{$i}}v2 = nil } else { v{{$i}}v2 = make(map[{{ .MapKey }}]{{ .Elem }}, len(v)) } // reset map
+	testUnmarshalErr(reflect.ValueOf(v{{$i}}v2), bs{{$i}}, h, t, "dec-map-v{{$i}}-noaddr") // decode into non-addressable map value
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-map-v{{$i}}-noaddr")
+    }
+	if v == nil { v{{$i}}v2 = nil } else { v{{$i}}v2 = make(map[{{ .MapKey }}]{{ .Elem }}, len(v)) } // reset map
+	testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-map-v{{$i}}-p-len")
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-map-v{{$i}}-p-len")
+	testReleaseBytes(bs{{$i}})
+	bs{{$i}} = testMarshalErr(&v{{$i}}v1, h, t, "enc-map-v{{$i}}-p")
+	v{{$i}}v2 = nil
+	testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-map-v{{$i}}-p-nil")
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-map-v{{$i}}-p-nil")
+	testReleaseBytes(bs{{$i}})
+    // ...
+	if v == nil { v{{$i}}v2 = nil } else { v{{$i}}v2 = make(map[{{ .MapKey }}]{{ .Elem }}, len(v)) } // reset map
+    var v{{$i}}v3, v{{$i}}v4 {{ .MethodNamePfx "typMap" false }}
+	v{{$i}}v3 = {{ .MethodNamePfx "typMap" false }}(v{{$i}}v1)
+	v{{$i}}v4 = {{ .MethodNamePfx "typMap" false }}(v{{$i}}v2)
+    if v != nil {
+    bs{{$i}} = testMarshalErr(v{{$i}}v3, h, t, "enc-map-v{{$i}}-custom")
+	testUnmarshalErr(v{{$i}}v4, bs{{$i}}, h, t, "dec-map-v{{$i}}-p-len")
+	testDeepEqualErr(v{{$i}}v3, v{{$i}}v4, t, "equal-map-v{{$i}}-p-len")
+	testReleaseBytes(bs{{$i}})
+    }
+    }
+{{end}}{{end}}{{end}}
+
+}
+
+func doTestMammothMapsAndSlices(t *testing.T, h Handle) {
+	defer testSetup(t, &h)()
+	if mh, ok := h.(*MsgpackHandle); ok {
+		defer func(b bool) { mh.RawToString = b }(mh.RawToString)
+		mh.RawToString = true
+	}
+	__doTestMammothSlices(t, h)
+	__doTestMammothMaps(t, h)
+}
+
+func doTestMammoth(t *testing.T, h Handle) {
+	defer testSetup(t, &h)()
+	if mh, ok := h.(*MsgpackHandle); ok {
+		defer func(b bool) { mh.RawToString = b }(mh.RawToString)
+		mh.RawToString = true
+	}
+
+	name := h.Name()
+	var b []byte
+
+	var m, m2 TestMammoth
+	testRandomFillRV(reflect.ValueOf(&m).Elem())
+	b = testMarshalErr(&m, h, t, "mammoth-"+name)
+
+	testUnmarshalErr(&m2, b, h, t, "mammoth-"+name)
+	testDeepEqualErr(&m, &m2, t, "mammoth-"+name)
+	testReleaseBytes(b)
+
+	if testing.Short() {
+		t.Skipf("skipping rest of mammoth test in -short mode")
+	}
+
+	var mm, mm2 TestMammoth2Wrapper
+	testRandomFillRV(reflect.ValueOf(&mm).Elem())
+	b = testMarshalErr(&mm, h, t, "mammoth2-"+name)
+	// os.Stderr.Write([]byte("\n\n\n\n" + string(b) + "\n\n\n\n"))
+	testUnmarshalErr(&mm2, b, h, t, "mammoth2-"+name)
+	testDeepEqualErr(&mm, &mm2, t, "mammoth2-"+name)
+	// testMammoth2(t, name, h)
+	testReleaseBytes(b)
+}
+
+{{range $i, $e := .Formats -}}
+func Test{{ . }}Mammoth(t *testing.T) {
+	doTestMammoth(t, test{{ . }}H)
+}
+{{end}}
+{{range $i, $e := .Formats -}}
+func Test{{ . }}MammothMapsAndSlices(t *testing.T) {
+	doTestMammothMapsAndSlices(t, test{{ . }}H)
+}
+{{end}}

vendor/github.com/ugorji/go/codec/mammoth2-test.go.tmpl

@@ -0,0 +1,101 @@
+// +build !codec.notmammoth
+
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+// Code generated from mammoth2-test.go.tmpl - DO NOT EDIT.
+
+package codec
+
+// Increase codecoverage by covering all the codecgen paths, in fast-path and gen-helper.go....
+//
+// Note: even though this is built based on fast-path and gen-helper, we will run these tests
+// in all modes, including notfastpath, etc.
+//
+// Add test file for creating a mammoth generated file as _mammoth_generated.go
+//  - generate a second mammoth files in a different file: mammoth2_generated_test.go
+//    mammoth-test.go.tmpl will do this
+//  - run codecgen on it, into mammoth2_codecgen_generated_test.go (no build tags)
+//  - as part of TestMammoth, run it also
+//  - this will cover all the codecgen, gen-helper, etc in one full run
+//  - check in mammoth* files into github also
+//
+// Now, add some types:
+//  - some that implement BinaryMarshal, TextMarshal, JSONMarshal, and one that implements none of it
+//  - create a wrapper type that includes TestMammoth2, with it in slices, and maps, and the custom types
+//  - this wrapper object is what we work encode/decode (so that the codecgen methods are called)
+
+
+// import "encoding/binary"
+
+import "fmt"
+
+type TestMammoth2 struct {
+
+{{range .Values }}{{if .Primitive }}{{/*
+*/}}{{ .MethodNamePfx "F" true }} {{ .Primitive }}
+{{ .MethodNamePfx "Fptr" true }} *{{ .Primitive }}
+{{end}}{{end}}
+
+{{range .Values }}{{if not .Primitive }}{{if not .MapKey }}{{/*
+*/}}{{ .MethodNamePfx "F" false }} []{{ .Elem }}
+{{ .MethodNamePfx "Fptr" false }} *[]{{ .Elem }}
+{{end}}{{end}}{{end}}
+
+{{range .Values }}{{if not .Primitive }}{{if .MapKey }}{{/*
+*/}}{{ .MethodNamePfx "F" false }} map[{{ .MapKey }}]{{ .Elem }}
+{{ .MethodNamePfx "Fptr" false }} *map[{{ .MapKey }}]{{ .Elem }}
+{{end}}{{end}}{{end}}
+
+}
+
+// -----------
+
+type testMammoth2Binary uint64
+func (x testMammoth2Binary) MarshalBinary() (data []byte, err error) {
+data = make([]byte, 8)
+bigenstd.PutUint64(data, uint64(x))
+return
+}
+func (x *testMammoth2Binary) UnmarshalBinary(data []byte) (err error) {
+*x = testMammoth2Binary(bigenstd.Uint64(data))
+return
+}
+
+type testMammoth2Text uint64
+func (x testMammoth2Text) MarshalText() (data []byte, err error) {
+data = []byte(fmt.Sprintf("%b", uint64(x)))
+return
+}
+func (x *testMammoth2Text) UnmarshalText(data []byte) (err error) {
+_, err = fmt.Sscanf(string(data), "%b", (*uint64)(x))
+return
+}
+
+type testMammoth2Json uint64
+func (x testMammoth2Json) MarshalJSON() (data []byte, err error) {
+data = []byte(fmt.Sprintf("%v", uint64(x)))
+return
+}
+func (x *testMammoth2Json) UnmarshalJSON(data []byte) (err error) {
+_, err = fmt.Sscanf(string(data), "%v", (*uint64)(x))
+return
+}
+
+type testMammoth2Basic [4]uint64
+
+type TestMammoth2Wrapper struct {
+	V TestMammoth2
+	T testMammoth2Text
+	B testMammoth2Binary
+	J testMammoth2Json
+	C testMammoth2Basic
+	M map[testMammoth2Basic]TestMammoth2
+	L []TestMammoth2
+	A [4]int64
+	
+  	Tcomplex128 complex128
+	Tcomplex64 complex64
+	Tbytes []uint8
+	Tpbytes *[]uint8
+}

vendor/github.com/ugorji/go/codec/reader.go

@@ -0,0 +1,816 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+package codec
+
+import "io"
+
+// decReader abstracts the reading source, allowing implementations that can
+// read from an io.Reader or directly off a byte slice with zero-copying.
+type decReader interface {
+	// readx will use the implementation scratch buffer if possible i.e. n < len(scratchbuf), OR
+	// just return a view of the []byte being decoded from.
+	readx(n uint) []byte
+	readb([]byte)
+
+	readn1() byte
+	readn2() [2]byte
+	// readn3 will read 3 bytes into the top-most elements of a 4-byte array
+	readn3() [4]byte
+	readn4() [4]byte
+	readn8() [8]byte
+	// readn1eof() (v uint8, eof bool)
+
+	// // read up to 8 bytes at a time
+	// readn(num uint8) (v [8]byte)
+
+	numread() uint // number of bytes read
+
+	// skip any whitespace characters, and return the first non-matching byte
+	skipWhitespace() (token byte)
+
+	// jsonReadNum will include last read byte in first element of slice,
+	// and continue numeric characters until it sees a non-numeric char
+	// or EOF. If it sees a non-numeric character, it will unread that.
+	jsonReadNum() []byte
+
+	// jsonReadAsisChars will read json plain characters (anything but " or \)
+	// and return a slice terminated by a non-json asis character.
+	jsonReadAsisChars() []byte
+
+	// skip will skip any byte that matches, and return the first non-matching byte
+	// skip(accept *bitset256) (token byte)
+
+	// readTo will read any byte that matches, stopping once no-longer matching.
+	// readTo(accept *bitset256) (out []byte)
+
+	// readUntil will read, only stopping once it matches the 'stop' byte (which it excludes).
+	readUntil(stop byte) (out []byte)
+}
+
+// ------------------------------------------------
+
+type unreadByteStatus uint8
+
+// unreadByteStatus goes from
+// undefined (when initialized) -- (read) --> canUnread -- (unread) --> canRead ...
+const (
+	unreadByteUndefined unreadByteStatus = iota
+	unreadByteCanRead
+	unreadByteCanUnread
+)
+
+// --------------------
+
+type ioDecReaderCommon struct {
+	r io.Reader // the reader passed in
+
+	n uint // num read
+
+	l  byte             // last byte
+	ls unreadByteStatus // last byte status
+
+	b [6]byte // tiny buffer for reading single bytes
+
+	blist *bytesFreelist
+
+	bufr []byte // buffer for readTo/readUntil
+}
+
+func (z *ioDecReaderCommon) reset(r io.Reader, blist *bytesFreelist) {
+	z.blist = blist
+	z.r = r
+	z.ls = unreadByteUndefined
+	z.l, z.n = 0, 0
+	z.bufr = z.blist.check(z.bufr, 256)
+}
+
+func (z *ioDecReaderCommon) numread() uint {
+	return z.n
+}
+
+// ------------------------------------------
+
+// ioDecReader is a decReader that reads off an io.Reader.
+//
+// It also has a fallback implementation of ByteScanner if needed.
+type ioDecReader struct {
+	ioDecReaderCommon
+
+	br io.ByteScanner
+
+	x [64 + 48]byte // for: get struct field name, swallow valueTypeBytes, etc
+}
+
+func (z *ioDecReader) reset(r io.Reader, blist *bytesFreelist) {
+	z.ioDecReaderCommon.reset(r, blist)
+
+	z.br, _ = r.(io.ByteScanner)
+}
+
+func (z *ioDecReader) Read(p []byte) (n int, err error) {
+	if len(p) == 0 {
+		return
+	}
+	var firstByte bool
+	if z.ls == unreadByteCanRead {
+		z.ls = unreadByteCanUnread
+		p[0] = z.l
+		if len(p) == 1 {
+			n = 1
+			return
+		}
+		firstByte = true
+		p = p[1:]
+	}
+	n, err = z.r.Read(p)
+	if n > 0 {
+		if err == io.EOF && n == len(p) {
+			err = nil // read was successful, so postpone EOF (till next time)
+		}
+		z.l = p[n-1]
+		z.ls = unreadByteCanUnread
+	}
+	if firstByte {
+		n++
+	}
+	return
+}
+
+func (z *ioDecReader) ReadByte() (c byte, err error) {
+	if z.br != nil {
+		c, err = z.br.ReadByte()
+		if err == nil {
+			z.l = c
+			z.ls = unreadByteCanUnread
+		}
+		return
+	}
+
+	n, err := z.Read(z.b[:1])
+	if n == 1 {
+		c = z.b[0]
+		if err == io.EOF {
+			err = nil // read was successful, so postpone EOF (till next time)
+		}
+	}
+	return
+}
+
+func (z *ioDecReader) UnreadByte() (err error) {
+	if z.br != nil {
+		err = z.br.UnreadByte()
+		if err == nil {
+			z.ls = unreadByteCanRead
+		}
+		return
+	}
+
+	switch z.ls {
+	case unreadByteCanUnread:
+		z.ls = unreadByteCanRead
+	case unreadByteCanRead:
+		err = errDecUnreadByteLastByteNotRead
+	case unreadByteUndefined:
+		err = errDecUnreadByteNothingToRead
+	default:
+		err = errDecUnreadByteUnknown
+	}
+	return
+}
+
+func (z *ioDecReader) readn2() (bs [2]byte) {
+	z.readb(bs[:])
+	return
+}
+
+func (z *ioDecReader) readn3() (bs [4]byte) {
+	z.readb(bs[1:])
+	return
+}
+
+func (z *ioDecReader) readn4() (bs [4]byte) {
+	z.readb(bs[:])
+	return
+}
+
+func (z *ioDecReader) readn8() (bs [8]byte) {
+	z.readb(bs[:])
+	return
+}
+
+func (z *ioDecReader) readx(n uint) (bs []byte) {
+	if n == 0 {
+		return
+	}
+	if n < uint(len(z.x)) {
+		bs = z.x[:n]
+	} else {
+		bs = make([]byte, n)
+	}
+	_, err := readFull(z.r, bs)
+	halt.onerror(err)
+	z.n += uint(len(bs))
+	return
+}
+
+func (z *ioDecReader) readb(bs []byte) {
+	if len(bs) == 0 {
+		return
+	}
+	_, err := readFull(z.r, bs)
+	halt.onerror(err)
+	z.n += uint(len(bs))
+}
+
+func (z *ioDecReader) readn1() (b uint8) {
+	b, err := z.ReadByte()
+	halt.onerror(err)
+	z.n++
+	return
+}
+
+func (z *ioDecReader) readn1eof() (b uint8, eof bool) {
+	b, err := z.ReadByte()
+	if err == nil {
+		z.n++
+	} else if err == io.EOF {
+		eof = true
+	} else {
+		halt.onerror(err)
+	}
+	return
+}
+
+func (z *ioDecReader) jsonReadNum() (bs []byte) {
+	z.unreadn1()
+	z.bufr = z.bufr[:0]
+LOOP:
+	i, eof := z.readn1eof()
+	if eof {
+		return z.bufr
+	}
+	if isNumberChar(i) {
+		z.bufr = append(z.bufr, i)
+		goto LOOP
+	}
+	z.unreadn1()
+	return z.bufr
+}
+
+func (z *ioDecReader) jsonReadAsisChars() (bs []byte) {
+	z.bufr = z.bufr[:0]
+LOOP:
+	i := z.readn1()
+	z.bufr = append(z.bufr, i)
+	if i == '"' || i == '\\' {
+		return z.bufr
+	}
+	goto LOOP
+}
+
+func (z *ioDecReader) skipWhitespace() (token byte) {
+LOOP:
+	token = z.readn1()
+	if isWhitespaceChar(token) {
+		goto LOOP
+	}
+	return
+}
+
+func (z *ioDecReader) readUntil(stop byte) []byte {
+	z.bufr = z.bufr[:0]
+LOOP:
+	token := z.readn1()
+	z.bufr = append(z.bufr, token)
+	if token == stop {
+		return z.bufr[:len(z.bufr)-1]
+	}
+	goto LOOP
+}
+
+func (z *ioDecReader) unreadn1() {
+	err := z.UnreadByte()
+	halt.onerror(err)
+	z.n--
+}
+
+// ------------------------------------
+
+type bufioDecReader struct {
+	ioDecReaderCommon
+
+	c   uint // cursor
+	buf []byte
+}
+
+func (z *bufioDecReader) reset(r io.Reader, bufsize int, blist *bytesFreelist) {
+	z.ioDecReaderCommon.reset(r, blist)
+	z.c = 0
+	if cap(z.buf) < bufsize {
+		z.buf = blist.get(bufsize)
+	} else {
+		z.buf = z.buf[:0]
+	}
+}
+
+func (z *bufioDecReader) readb(p []byte) {
+	var n = uint(copy(p, z.buf[z.c:]))
+	z.n += n
+	z.c += n
+	if len(p) != int(n) {
+		z.readbFill(p, n, true, false)
+	}
+}
+
+func readbFillHandleErr(err error, must, eof bool) (isEOF bool) {
+	if err == io.EOF {
+		isEOF = true
+	}
+	if must && !(eof && isEOF) {
+		halt.onerror(err)
+	}
+	return
+}
+
+func (z *bufioDecReader) readbFill(p0 []byte, n uint, must, eof bool) (isEOF bool, err error) {
+	// at this point, there's nothing in z.buf to read (z.buf is fully consumed)
+	var p []byte
+	if p0 != nil {
+		p = p0[n:]
+	}
+	var n2 uint
+	if len(p) > cap(z.buf) {
+		n2, err = readFull(z.r, p)
+		if err != nil {
+			isEOF = readbFillHandleErr(err, must, eof)
+			return
+		}
+		n += n2
+		z.n += n2
+		// always keep last byte in z.buf
+		z.buf = z.buf[:1]
+		z.buf[0] = p[len(p)-1]
+		z.c = 1
+		return
+	}
+	// z.c is now 0, and len(p) <= cap(z.buf)
+	var n1 int
+LOOP:
+	// for len(p) > 0 && z.err == nil {
+	z.buf = z.buf[0:cap(z.buf)]
+	n1, err = z.r.Read(z.buf)
+	n2 = uint(n1)
+	if n2 == 0 && err != nil {
+		isEOF = readbFillHandleErr(err, must, eof)
+		return
+	}
+	err = nil
+	z.buf = z.buf[:n2]
+	z.c = 0
+	if len(p) > 0 {
+		n2 = uint(copy(p, z.buf))
+		z.c = n2
+		n += n2
+		z.n += n2
+		p = p[n2:]
+		if len(p) > 0 {
+			goto LOOP
+		}
+		if z.c == 0 {
+			z.buf = z.buf[:1]
+			z.buf[0] = p[len(p)-1]
+			z.c = 1
+		}
+	}
+	return
+}
+
+func (z *bufioDecReader) readn1() (b byte) {
+	if z.c >= uint(len(z.buf)) {
+		z.readbFill(nil, 0, true, false)
+	}
+	b = z.buf[z.c]
+	z.c++
+	z.n++
+	return
+}
+
+func (z *bufioDecReader) readn1eof() (b byte, eof bool) {
+	if z.c >= uint(len(z.buf)) {
+		eof, _ = z.readbFill(nil, 0, true, true)
+		if eof {
+			return
+		}
+	}
+	b = z.buf[z.c]
+	z.c++
+	z.n++
+	return
+}
+
+func (z *bufioDecReader) unreadn1() {
+	if z.c == 0 {
+		halt.onerror(errDecUnreadByteNothingToRead)
+	}
+	z.c--
+	z.n--
+}
+
+func (z *bufioDecReader) readn2() (bs [2]byte) {
+	z.readb(bs[:])
+	return
+}
+
+func (z *bufioDecReader) readn3() (bs [4]byte) {
+	z.readb(bs[1:])
+	return
+}
+
+func (z *bufioDecReader) readn4() (bs [4]byte) {
+	z.readb(bs[:])
+	return
+}
+
+func (z *bufioDecReader) readn8() (bs [8]byte) {
+	z.readb(bs[:])
+	return
+}
+
+func (z *bufioDecReader) readx(n uint) (bs []byte) {
+	if n == 0 {
+		// return
+	} else if z.c+n <= uint(len(z.buf)) {
+		bs = z.buf[z.c : z.c+n]
+		z.n += n
+		z.c += n
+	} else {
+		bs = make([]byte, n)
+		// n no longer used - can reuse
+		n = uint(copy(bs, z.buf[z.c:]))
+		z.n += n
+		z.c += n
+		z.readbFill(bs, n, true, false)
+	}
+	return
+}
+
+func (z *bufioDecReader) jsonReadNum() (bs []byte) {
+	z.unreadn1()
+	z.bufr = z.bufr[:0]
+LOOP:
+	i, eof := z.readn1eof()
+	if eof {
+		return z.bufr
+	}
+	if isNumberChar(i) {
+		z.bufr = append(z.bufr, i)
+		goto LOOP
+	}
+	z.unreadn1()
+	return z.bufr
+}
+
+func (z *bufioDecReader) jsonReadAsisChars() (bs []byte) {
+	z.bufr = z.bufr[:0]
+LOOP:
+	i := z.readn1()
+	z.bufr = append(z.bufr, i)
+	if i == '"' || i == '\\' {
+		return z.bufr
+	}
+	goto LOOP
+}
+
+func (z *bufioDecReader) skipWhitespace() (token byte) {
+	i := z.c
+LOOP:
+	if i < uint(len(z.buf)) {
+		// inline z.skipLoopFn(i) and refactor, so cost is within inline budget
+		token = z.buf[i]
+		i++
+		if isWhitespaceChar(token) {
+			goto LOOP
+		}
+		z.n += i - 2 - z.c
+		z.c = i
+		return
+	}
+	return z.skipFillWhitespace()
+}
+
+func (z *bufioDecReader) skipFillWhitespace() (token byte) {
+	z.n += uint(len(z.buf)) - z.c
+	var i, n2 int
+	var err error
+	for {
+		z.c = 0
+		z.buf = z.buf[0:cap(z.buf)]
+		n2, err = z.r.Read(z.buf)
+		if n2 == 0 {
+			halt.onerror(err)
+		}
+		z.buf = z.buf[:n2]
+		for i, token = range z.buf {
+			if !isWhitespaceChar(token) {
+				z.n += (uint(i) - z.c) - 1
+				z.loopFn(uint(i + 1))
+				return
+			}
+		}
+		z.n += uint(n2)
+	}
+}
+
+func (z *bufioDecReader) loopFn(i uint) {
+	z.c = i
+}
+
+func (z *bufioDecReader) readUntil(stop byte) (out []byte) {
+	i := z.c
+LOOP:
+	if i < uint(len(z.buf)) {
+		if z.buf[i] == stop {
+			z.n += (i - z.c) - 1
+			i++
+			out = z.buf[z.c:i]
+			z.c = i
+			goto FINISH
+		}
+		i++
+		goto LOOP
+	}
+	out = z.readUntilFill(stop)
+FINISH:
+	return out[:len(out)-1]
+}
+
+func (z *bufioDecReader) readUntilFill(stop byte) []byte {
+	z.bufr = z.bufr[:0]
+	z.n += uint(len(z.buf)) - z.c
+	z.bufr = append(z.bufr, z.buf[z.c:]...)
+	for {
+		z.c = 0
+		z.buf = z.buf[0:cap(z.buf)]
+		n1, err := z.r.Read(z.buf)
+		if n1 == 0 {
+			halt.onerror(err)
+		}
+		n2 := uint(n1)
+		z.buf = z.buf[:n2]
+		for i, token := range z.buf {
+			if token == stop {
+				z.n += (uint(i) - z.c) - 1
+				z.bufr = append(z.bufr, z.buf[z.c:i+1]...)
+				z.loopFn(uint(i + 1))
+				return z.bufr
+			}
+		}
+		z.bufr = append(z.bufr, z.buf...)
+		z.n += n2
+	}
+}
+
+// ------------------------------------
+
+// bytesDecReader is a decReader that reads off a byte slice with zero copying
+//
+// Note: we do not try to convert index'ing out of bounds to an io.EOF.
+// instead, we let it bubble up to the exported Encode/Decode method
+// and recover it as an io.EOF.
+//
+// see panicValToErr(...) function in helper.go.
+type bytesDecReader struct {
+	b []byte // data
+	c uint   // cursor
+}
+
+func (z *bytesDecReader) reset(in []byte) {
+	z.b = in[:len(in):len(in)] // reslicing must not go past capacity
+	z.c = 0
+}
+
+func (z *bytesDecReader) numread() uint {
+	return z.c
+}
+
+// Note: slicing from a non-constant start position is more expensive,
+// as more computation is required to decipher the pointer start position.
+// However, we do it only once, and it's better than reslicing both z.b and return value.
+
+func (z *bytesDecReader) readx(n uint) (bs []byte) {
+	x := z.c + n
+	bs = z.b[z.c:x]
+	z.c = x
+	return
+}
+
+func (z *bytesDecReader) readb(bs []byte) {
+	copy(bs, z.readx(uint(len(bs))))
+}
+
+// MARKER: do not use this - as it calls into memmove (as the size of data to move is unknown)
+// func (z *bytesDecReader) readnn(bs []byte, n uint) {
+// 	x := z.c
+// 	copy(bs, z.b[x:x+n])
+// 	z.c += n
+// }
+
+// func (z *bytesDecReader) readn(num uint8) (bs [8]byte) {
+// 	x := z.c + uint(num)
+// 	copy(bs[:], z.b[z.c:x]) // slice z.b completely, so we get bounds error if past
+// 	z.c = x
+// 	return
+// }
+
+// func (z *bytesDecReader) readn1() uint8 {
+// 	z.c++
+// 	return z.b[z.c-1]
+// }
+
+func (z *bytesDecReader) readn1() (v uint8) {
+	v = z.b[z.c]
+	z.c++
+	return
+}
+
+// MARKER: for readn{2,3,4,8}, ensure you slice z.b completely so we get bounds error if past end.
+
+func (z *bytesDecReader) readn2() (bs [2]byte) {
+	// copy(bs[:], z.b[z.c:z.c+2])
+	bs[1] = z.b[z.c+1]
+	bs[0] = z.b[z.c]
+	z.c += 2
+	return
+}
+
+func (z *bytesDecReader) readn3() (bs [4]byte) {
+	// copy(bs[1:], z.b[z.c:z.c+3])
+	bs = okBytes3(z.b[z.c : z.c+3])
+	z.c += 3
+	return
+}
+
+func (z *bytesDecReader) readn4() (bs [4]byte) {
+	// copy(bs[:], z.b[z.c:z.c+4])
+	bs = okBytes4(z.b[z.c : z.c+4])
+	z.c += 4
+	return
+}
+
+func (z *bytesDecReader) readn8() (bs [8]byte) {
+	// copy(bs[:], z.b[z.c:z.c+8])
+	bs = okBytes8(z.b[z.c : z.c+8])
+	z.c += 8
+	return
+}
+
+func (z *bytesDecReader) jsonReadNum() []byte {
+	z.c--
+	i := z.c
+LOOP:
+	if i < uint(len(z.b)) && isNumberChar(z.b[i]) {
+		i++
+		goto LOOP
+	}
+	z.c, i = i, z.c
+	return z.b[i:z.c]
+}
+
+func (z *bytesDecReader) jsonReadAsisChars() []byte {
+	i := z.c
+LOOP:
+	token := z.b[i]
+	i++
+	if token == '"' || token == '\\' {
+		z.c, i = i, z.c
+		return z.b[i:z.c]
+	}
+	goto LOOP
+}
+
+func (z *bytesDecReader) skipWhitespace() (token byte) {
+	i := z.c
+LOOP:
+	token = z.b[i]
+	if isWhitespaceChar(token) {
+		i++
+		goto LOOP
+	}
+	z.c = i + 1
+	return
+}
+
+func (z *bytesDecReader) readUntil(stop byte) (out []byte) {
+	i := z.c
+LOOP:
+	if z.b[i] == stop {
+		out = z.b[z.c:i]
+		z.c = i + 1
+		return
+	}
+	i++
+	goto LOOP
+}
+
+// --------------
+
+type decRd struct {
+	mtr bool // is maptype a known type?
+	str bool // is slicetype a known type?
+
+	be   bool // is binary encoding
+	js   bool // is json handle
+	jsms bool // is json handle, and MapKeyAsString
+	cbor bool // is cbor handle
+
+	bytes bool // is bytes reader
+	bufio bool // is this a bufioDecReader?
+
+	rb bytesDecReader
+	ri *ioDecReader
+	bi *bufioDecReader
+
+	decReader
+}
+
+// From out benchmarking, we see the following in terms of performance:
+//
+// - interface calls
+// - branch that can inline what it calls
+//
+// the if/else-if/else block is expensive to inline.
+// Each node of this construct costs a lot and dominates the budget.
+// Best to only do an if fast-path else block (so fast-path is inlined).
+// This is irrespective of inlineExtraCallCost set in $GOROOT/src/cmd/compile/internal/gc/inl.go
+//
+// In decRd methods below, we delegate all IO functions into their own methods.
+// This allows for the inlining of the common path when z.bytes=true.
+// Go 1.12+ supports inlining methods with up to 1 inlined function (or 2 if no other constructs).
+//
+// However, up through Go 1.13, decRd's readXXX, skip and unreadXXX methods are not inlined.
+// Consequently, there is no benefit to do the xxxIO methods for decRd at this time.
+// Instead, we have a if/else-if/else block so that IO calls do not have to jump through
+// a second unnecessary function call.
+//
+// If golang inlining gets better and bytesDecReader methods can be inlined,
+// then we can revert to using these 2 functions so the bytesDecReader
+// methods are inlined and the IO paths call out to a function.
+//
+// decRd is designed to embed a decReader, and then re-implement some of the decReader
+// methods using a conditional branch. We only override the ones that have a bytes version
+// that is small enough to be inlined. We use ./run.sh -z to check.
+// Right now, only numread and readn1 can be inlined.
+
+func (z *decRd) numread() uint {
+	if z.bytes {
+		return z.rb.numread()
+	} else if z.bufio {
+		return z.bi.numread()
+	} else {
+		return z.ri.numread()
+	}
+}
+
+func (z *decRd) readn1() (v uint8) {
+	if z.bytes {
+		// MARKER: manually inline, else this function is not inlined.
+		// Keep in sync with bytesDecReader.readn1
+		// return z.rb.readn1()
+		v = z.rb.b[z.rb.c]
+		z.rb.c++
+	} else {
+		v = z.readn1IO()
+	}
+	return
+}
+func (z *decRd) readn1IO() uint8 {
+	if z.bufio {
+		return z.bi.readn1()
+	}
+	return z.ri.readn1()
+}
+
+type devNullReader struct{}
+
+func (devNullReader) Read(p []byte) (int, error) { return 0, io.EOF }
+func (devNullReader) Close() error               { return nil }
+
+func readFull(r io.Reader, bs []byte) (n uint, err error) {
+	var nn int
+	for n < uint(len(bs)) && err == nil {
+		nn, err = r.Read(bs[n:])
+		if nn > 0 {
+			if err == io.EOF {
+				// leave EOF for next time
+				err = nil
+			}
+			n += uint(nn)
+		}
+	}
+	// do not do this below - it serves no purpose
+	// if n != len(bs) && err == io.EOF { err = io.ErrUnexpectedEOF }
+	return
+}
+
+var _ decReader = (*decRd)(nil)

vendor/github.com/ugorji/go/codec/register_ext.go

@@ -0,0 +1,38 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+package codec
+
+import "reflect"
+
+// This file exists, so that the files for specific formats do not all import reflect.
+// This just helps us ensure that reflect package is isolated to a few files.
+
+// SetInterfaceExt sets an extension
+func (h *JsonHandle) SetInterfaceExt(rt reflect.Type, tag uint64, ext InterfaceExt) (err error) {
+	return h.SetExt(rt, tag, makeExt(ext))
+}
+
+// SetInterfaceExt sets an extension
+func (h *CborHandle) SetInterfaceExt(rt reflect.Type, tag uint64, ext InterfaceExt) (err error) {
+	return h.SetExt(rt, tag, makeExt(ext))
+}
+
+// SetBytesExt sets an extension
+func (h *MsgpackHandle) SetBytesExt(rt reflect.Type, tag uint64, ext BytesExt) (err error) {
+	return h.SetExt(rt, tag, makeExt(ext))
+}
+
+// SetBytesExt sets an extension
+func (h *SimpleHandle) SetBytesExt(rt reflect.Type, tag uint64, ext BytesExt) (err error) {
+	return h.SetExt(rt, tag, makeExt(ext))
+}
+
+// SetBytesExt sets an extension
+func (h *BincHandle) SetBytesExt(rt reflect.Type, tag uint64, ext BytesExt) (err error) {
+	return h.SetExt(rt, tag, makeExt(ext))
+}
+
+// func (h *XMLHandle) SetInterfaceExt(rt reflect.Type, tag uint64, ext InterfaceExt) (err error) {
+// 	return h.SetExt(rt, tag, &interfaceExtWrapper{InterfaceExt: ext})
+// }

vendor/github.com/ugorji/go/codec/rpc.go

@@ -0,0 +1,232 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+package codec
+
+import (
+	"bufio"
+	"errors"
+	"io"
+	"net/rpc"
+)
+
+var (
+	errRpcIsClosed = errors.New("rpc - connection has been closed")
+	errRpcNoConn   = errors.New("rpc - no connection")
+
+	rpcSpaceArr = [1]byte{' '}
+)
+
+// Rpc provides a rpc Server or Client Codec for rpc communication.
+type Rpc interface {
+	ServerCodec(conn io.ReadWriteCloser, h Handle) rpc.ServerCodec
+	ClientCodec(conn io.ReadWriteCloser, h Handle) rpc.ClientCodec
+}
+
+// RPCOptions holds options specific to rpc functionality
+type RPCOptions struct {
+	// RPCNoBuffer configures whether we attempt to buffer reads and writes during RPC calls.
+	//
+	// Set RPCNoBuffer=true to turn buffering off.
+	// Buffering can still be done if buffered connections are passed in, or
+	// buffering is configured on the handle.
+	RPCNoBuffer bool
+}
+
+// rpcCodec defines the struct members and common methods.
+type rpcCodec struct {
+	c io.Closer
+	r io.Reader
+	w io.Writer
+	f ioFlusher
+
+	dec *Decoder
+	enc *Encoder
+	h   Handle
+
+	cls atomicClsErr
+}
+
+func newRPCCodec(conn io.ReadWriteCloser, h Handle) rpcCodec {
+	return newRPCCodec2(conn, conn, conn, h)
+}
+
+func newRPCCodec2(r io.Reader, w io.Writer, c io.Closer, h Handle) rpcCodec {
+	bh := h.getBasicHandle()
+	// if the writer can flush, ensure we leverage it, else
+	// we may hang waiting on read if write isn't flushed.
+	// var f ioFlusher
+	f, ok := w.(ioFlusher)
+	if !bh.RPCNoBuffer {
+		if bh.WriterBufferSize <= 0 {
+			if !ok { // a flusher means there's already a buffer
+				bw := bufio.NewWriter(w)
+				f, w = bw, bw
+			}
+		}
+		if bh.ReaderBufferSize <= 0 {
+			if _, ok = w.(ioBuffered); !ok {
+				r = bufio.NewReader(r)
+			}
+		}
+	}
+	return rpcCodec{
+		c:   c,
+		w:   w,
+		r:   r,
+		f:   f,
+		h:   h,
+		enc: NewEncoder(w, h),
+		dec: NewDecoder(r, h),
+	}
+}
+
+func (c *rpcCodec) write(obj ...interface{}) (err error) {
+	err = c.ready()
+	if err != nil {
+		return
+	}
+	if c.f != nil {
+		defer func() {
+			flushErr := c.f.Flush()
+			if flushErr != nil && err == nil {
+				err = flushErr
+			}
+		}()
+	}
+
+	for _, o := range obj {
+		err = c.enc.Encode(o)
+		if err != nil {
+			return
+		}
+		// defensive: ensure a space is always written after each encoding,
+		// in case the value was a number, and encoding a value right after
+		// without a space will lead to invalid output.
+		if c.h.isJson() {
+			_, err = c.w.Write(rpcSpaceArr[:])
+			if err != nil {
+				return
+			}
+		}
+	}
+	return
+}
+
+func (c *rpcCodec) read(obj interface{}) (err error) {
+	err = c.ready()
+	if err == nil {
+		//If nil is passed in, we should read and discard
+		if obj == nil {
+			// return c.dec.Decode(&obj)
+			err = c.dec.swallowErr()
+		} else {
+			err = c.dec.Decode(obj)
+		}
+	}
+	return
+}
+
+func (c *rpcCodec) Close() (err error) {
+	if c.c != nil {
+		cls := c.cls.load()
+		if !cls.closed {
+			cls.err = c.c.Close()
+			cls.closed = true
+			c.cls.store(cls)
+		}
+		err = cls.err
+	}
+	return
+}
+
+func (c *rpcCodec) ready() (err error) {
+	if c.c == nil {
+		err = errRpcNoConn
+	} else {
+		cls := c.cls.load()
+		if cls.closed {
+			if err = cls.err; err == nil {
+				err = errRpcIsClosed
+			}
+		}
+	}
+	return
+}
+
+func (c *rpcCodec) ReadResponseBody(body interface{}) error {
+	return c.read(body)
+}
+
+// -------------------------------------
+
+type goRpcCodec struct {
+	rpcCodec
+}
+
+func (c *goRpcCodec) WriteRequest(r *rpc.Request, body interface{}) error {
+	return c.write(r, body)
+}
+
+func (c *goRpcCodec) WriteResponse(r *rpc.Response, body interface{}) error {
+	return c.write(r, body)
+}
+
+func (c *goRpcCodec) ReadResponseHeader(r *rpc.Response) error {
+	return c.read(r)
+}
+
+func (c *goRpcCodec) ReadRequestHeader(r *rpc.Request) error {
+	return c.read(r)
+}
+
+func (c *goRpcCodec) ReadRequestBody(body interface{}) error {
+	return c.read(body)
+}
+
+// -------------------------------------
+
+// goRpc is the implementation of Rpc that uses the communication protocol
+// as defined in net/rpc package.
+type goRpc struct{}
+
+// GoRpc implements Rpc using the communication protocol defined in net/rpc package.
+//
+// Note: network connection (from net.Dial, of type io.ReadWriteCloser) is not buffered.
+//
+// For performance, you should configure WriterBufferSize and ReaderBufferSize on the handle.
+// This ensures we use an adequate buffer during reading and writing.
+// If not configured, we will internally initialize and use a buffer during reads and writes.
+// This can be turned off via the RPCNoBuffer option on the Handle.
+//   var handle codec.JsonHandle
+//   handle.RPCNoBuffer = true // turns off attempt by rpc module to initialize a buffer
+//
+// Example 1: one way of configuring buffering explicitly:
+//   var handle codec.JsonHandle // codec handle
+//   handle.ReaderBufferSize = 1024
+//   handle.WriterBufferSize = 1024
+//   var conn io.ReadWriteCloser // connection got from a socket
+//   var serverCodec = GoRpc.ServerCodec(conn, handle)
+//   var clientCodec = GoRpc.ClientCodec(conn, handle)
+//
+// Example 2: you can also explicitly create a buffered connection yourself,
+// and not worry about configuring the buffer sizes in the Handle.
+//   var handle codec.Handle     // codec handle
+//   var conn io.ReadWriteCloser // connection got from a socket
+//   var bufconn = struct {      // bufconn here is a buffered io.ReadWriteCloser
+//       io.Closer
+//       *bufio.Reader
+//       *bufio.Writer
+//   }{conn, bufio.NewReader(conn), bufio.NewWriter(conn)}
+//   var serverCodec = GoRpc.ServerCodec(bufconn, handle)
+//   var clientCodec = GoRpc.ClientCodec(bufconn, handle)
+//
+var GoRpc goRpc
+
+func (x goRpc) ServerCodec(conn io.ReadWriteCloser, h Handle) rpc.ServerCodec {
+	return &goRpcCodec{newRPCCodec(conn, h)}
+}
+
+func (x goRpc) ClientCodec(conn io.ReadWriteCloser, h Handle) rpc.ClientCodec {
+	return &goRpcCodec{newRPCCodec(conn, h)}
+}

vendor/github.com/ugorji/go/codec/simple.go

@@ -0,0 +1,747 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+package codec
+
+import (
+	"math"
+	"reflect"
+	"time"
+)
+
+const (
+	_               uint8 = iota
+	simpleVdNil           = 1
+	simpleVdFalse         = 2
+	simpleVdTrue          = 3
+	simpleVdFloat32       = 4
+	simpleVdFloat64       = 5
+
+	// each lasts for 4 (ie n, n+1, n+2, n+3)
+	simpleVdPosInt = 8
+	simpleVdNegInt = 12
+
+	simpleVdTime = 24
+
+	// containers: each lasts for 4 (ie n, n+1, n+2, ... n+7)
+	simpleVdString    = 216
+	simpleVdByteArray = 224
+	simpleVdArray     = 232
+	simpleVdMap       = 240
+	simpleVdExt       = 248
+)
+
+var simpledescNames = map[byte]string{
+	simpleVdNil:     "null",
+	simpleVdFalse:   "false",
+	simpleVdTrue:    "true",
+	simpleVdFloat32: "float32",
+	simpleVdFloat64: "float64",
+
+	simpleVdPosInt: "+int",
+	simpleVdNegInt: "-int",
+
+	simpleVdTime: "time",
+
+	simpleVdString:    "string",
+	simpleVdByteArray: "binary",
+	simpleVdArray:     "array",
+	simpleVdMap:       "map",
+	simpleVdExt:       "ext",
+}
+
+func simpledesc(bd byte) (s string) {
+	s = simpledescNames[bd]
+	if s == "" {
+		s = "unknown"
+	}
+	return
+}
+
+type simpleEncDriver struct {
+	noBuiltInTypes
+	encDriverNoopContainerWriter
+	encDriverNoState
+	h *SimpleHandle
+	// b [8]byte
+	e Encoder
+}
+
+func (e *simpleEncDriver) encoder() *Encoder {
+	return &e.e
+}
+
+func (e *simpleEncDriver) EncodeNil() {
+	e.e.encWr.writen1(simpleVdNil)
+}
+
+func (e *simpleEncDriver) EncodeBool(b bool) {
+	if e.h.EncZeroValuesAsNil && e.e.c != containerMapKey && !b {
+		e.EncodeNil()
+		return
+	}
+	if b {
+		e.e.encWr.writen1(simpleVdTrue)
+	} else {
+		e.e.encWr.writen1(simpleVdFalse)
+	}
+}
+
+func (e *simpleEncDriver) EncodeFloat32(f float32) {
+	if e.h.EncZeroValuesAsNil && e.e.c != containerMapKey && f == 0.0 {
+		e.EncodeNil()
+		return
+	}
+	e.e.encWr.writen1(simpleVdFloat32)
+	bigen.writeUint32(e.e.w(), math.Float32bits(f))
+}
+
+func (e *simpleEncDriver) EncodeFloat64(f float64) {
+	if e.h.EncZeroValuesAsNil && e.e.c != containerMapKey && f == 0.0 {
+		e.EncodeNil()
+		return
+	}
+	e.e.encWr.writen1(simpleVdFloat64)
+	bigen.writeUint64(e.e.w(), math.Float64bits(f))
+}
+
+func (e *simpleEncDriver) EncodeInt(v int64) {
+	if v < 0 {
+		e.encUint(uint64(-v), simpleVdNegInt)
+	} else {
+		e.encUint(uint64(v), simpleVdPosInt)
+	}
+}
+
+func (e *simpleEncDriver) EncodeUint(v uint64) {
+	e.encUint(v, simpleVdPosInt)
+}
+
+func (e *simpleEncDriver) encUint(v uint64, bd uint8) {
+	if e.h.EncZeroValuesAsNil && e.e.c != containerMapKey && v == 0 {
+		e.EncodeNil()
+		return
+	}
+	if v <= math.MaxUint8 {
+		e.e.encWr.writen2(bd, uint8(v))
+	} else if v <= math.MaxUint16 {
+		e.e.encWr.writen1(bd + 1)
+		bigen.writeUint16(e.e.w(), uint16(v))
+	} else if v <= math.MaxUint32 {
+		e.e.encWr.writen1(bd + 2)
+		bigen.writeUint32(e.e.w(), uint32(v))
+	} else { // if v <= math.MaxUint64 {
+		e.e.encWr.writen1(bd + 3)
+		bigen.writeUint64(e.e.w(), v)
+	}
+}
+
+func (e *simpleEncDriver) encLen(bd byte, length int) {
+	if length == 0 {
+		e.e.encWr.writen1(bd)
+	} else if length <= math.MaxUint8 {
+		e.e.encWr.writen1(bd + 1)
+		e.e.encWr.writen1(uint8(length))
+	} else if length <= math.MaxUint16 {
+		e.e.encWr.writen1(bd + 2)
+		bigen.writeUint16(e.e.w(), uint16(length))
+	} else if int64(length) <= math.MaxUint32 {
+		e.e.encWr.writen1(bd + 3)
+		bigen.writeUint32(e.e.w(), uint32(length))
+	} else {
+		e.e.encWr.writen1(bd + 4)
+		bigen.writeUint64(e.e.w(), uint64(length))
+	}
+}
+
+func (e *simpleEncDriver) EncodeExt(v interface{}, basetype reflect.Type, xtag uint64, ext Ext) {
+	var bs0, bs []byte
+	if ext == SelfExt {
+		bs0 = e.e.blist.get(1024)
+		bs = bs0
+		e.e.sideEncode(v, basetype, &bs)
+	} else {
+		bs = ext.WriteExt(v)
+	}
+	if bs == nil {
+		e.EncodeNil()
+		goto END
+	}
+	e.encodeExtPreamble(uint8(xtag), len(bs))
+	e.e.encWr.writeb(bs)
+END:
+	if ext == SelfExt {
+		e.e.blist.put(bs)
+		if !byteSliceSameData(bs0, bs) {
+			e.e.blist.put(bs0)
+		}
+	}
+}
+
+func (e *simpleEncDriver) EncodeRawExt(re *RawExt) {
+	e.encodeExtPreamble(uint8(re.Tag), len(re.Data))
+	e.e.encWr.writeb(re.Data)
+}
+
+func (e *simpleEncDriver) encodeExtPreamble(xtag byte, length int) {
+	e.encLen(simpleVdExt, length)
+	e.e.encWr.writen1(xtag)
+}
+
+func (e *simpleEncDriver) WriteArrayStart(length int) {
+	e.encLen(simpleVdArray, length)
+}
+
+func (e *simpleEncDriver) WriteMapStart(length int) {
+	e.encLen(simpleVdMap, length)
+}
+
+func (e *simpleEncDriver) EncodeString(v string) {
+	if e.h.EncZeroValuesAsNil && e.e.c != containerMapKey && v == "" {
+		e.EncodeNil()
+		return
+	}
+	if e.h.StringToRaw {
+		e.encLen(simpleVdByteArray, len(v))
+	} else {
+		e.encLen(simpleVdString, len(v))
+	}
+	e.e.encWr.writestr(v)
+}
+
+func (e *simpleEncDriver) EncodeStringBytesRaw(v []byte) {
+	// if e.h.EncZeroValuesAsNil && e.c != containerMapKey && v == nil {
+	if v == nil {
+		e.EncodeNil()
+		return
+	}
+	e.encLen(simpleVdByteArray, len(v))
+	e.e.encWr.writeb(v)
+}
+
+func (e *simpleEncDriver) EncodeTime(t time.Time) {
+	// if e.h.EncZeroValuesAsNil && e.c != containerMapKey && t.IsZero() {
+	if t.IsZero() {
+		e.EncodeNil()
+		return
+	}
+	v, err := t.MarshalBinary()
+	e.e.onerror(err)
+	e.e.encWr.writen2(simpleVdTime, uint8(len(v)))
+	e.e.encWr.writeb(v)
+}
+
+//------------------------------------
+
+type simpleDecDriver struct {
+	h *SimpleHandle
+	bdAndBdread
+	_ bool
+	noBuiltInTypes
+	decDriverNoopContainerReader
+	decDriverNoopNumberHelper
+	d Decoder
+}
+
+func (d *simpleDecDriver) decoder() *Decoder {
+	return &d.d
+}
+
+func (d *simpleDecDriver) descBd() string {
+	return sprintf("%v (%s)", d.bd, simpledesc(d.bd))
+}
+
+func (d *simpleDecDriver) readNextBd() {
+	d.bd = d.d.decRd.readn1()
+	d.bdRead = true
+}
+
+func (d *simpleDecDriver) advanceNil() (null bool) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
+	if d.bd == simpleVdNil {
+		d.bdRead = false
+		return true // null = true
+	}
+	return
+}
+
+func (d *simpleDecDriver) ContainerType() (vt valueType) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
+	switch d.bd {
+	case simpleVdNil:
+		d.bdRead = false
+		return valueTypeNil
+	case simpleVdByteArray, simpleVdByteArray + 1,
+		simpleVdByteArray + 2, simpleVdByteArray + 3, simpleVdByteArray + 4:
+		return valueTypeBytes
+	case simpleVdString, simpleVdString + 1,
+		simpleVdString + 2, simpleVdString + 3, simpleVdString + 4:
+		return valueTypeString
+	case simpleVdArray, simpleVdArray + 1,
+		simpleVdArray + 2, simpleVdArray + 3, simpleVdArray + 4:
+		return valueTypeArray
+	case simpleVdMap, simpleVdMap + 1,
+		simpleVdMap + 2, simpleVdMap + 3, simpleVdMap + 4:
+		return valueTypeMap
+	}
+	return valueTypeUnset
+}
+
+func (d *simpleDecDriver) TryNil() bool {
+	return d.advanceNil()
+}
+
+func (d *simpleDecDriver) decFloat() (f float64, ok bool) {
+	ok = true
+	switch d.bd {
+	case simpleVdFloat32:
+		f = float64(math.Float32frombits(bigen.Uint32(d.d.decRd.readn4())))
+	case simpleVdFloat64:
+		f = math.Float64frombits(bigen.Uint64(d.d.decRd.readn8()))
+	default:
+		ok = false
+	}
+	return
+}
+
+func (d *simpleDecDriver) decInteger() (ui uint64, neg, ok bool) {
+	ok = true
+	switch d.bd {
+	case simpleVdPosInt:
+		ui = uint64(d.d.decRd.readn1())
+	case simpleVdPosInt + 1:
+		ui = uint64(bigen.Uint16(d.d.decRd.readn2()))
+	case simpleVdPosInt + 2:
+		ui = uint64(bigen.Uint32(d.d.decRd.readn4()))
+	case simpleVdPosInt + 3:
+		ui = uint64(bigen.Uint64(d.d.decRd.readn8()))
+	case simpleVdNegInt:
+		ui = uint64(d.d.decRd.readn1())
+		neg = true
+	case simpleVdNegInt + 1:
+		ui = uint64(bigen.Uint16(d.d.decRd.readn2()))
+		neg = true
+	case simpleVdNegInt + 2:
+		ui = uint64(bigen.Uint32(d.d.decRd.readn4()))
+		neg = true
+	case simpleVdNegInt + 3:
+		ui = uint64(bigen.Uint64(d.d.decRd.readn8()))
+		neg = true
+	default:
+		ok = false
+		// d.d.errorf("integer only valid from pos/neg integer1..8. Invalid descriptor: %v", d.bd)
+	}
+	// DO NOT do this check below, because callers may only want the unsigned value:
+	//
+	// if ui > math.MaxInt64 {
+	// 	d.d.errorf("decIntAny: Integer out of range for signed int64: %v", ui)
+	//		return
+	// }
+	return
+}
+
+func (d *simpleDecDriver) DecodeInt64() (i int64) {
+	if d.advanceNil() {
+		return
+	}
+	i = decNegintPosintFloatNumberHelper{&d.d}.int64(d.decInteger())
+	d.bdRead = false
+	return
+}
+
+func (d *simpleDecDriver) DecodeUint64() (ui uint64) {
+	if d.advanceNil() {
+		return
+	}
+	ui = decNegintPosintFloatNumberHelper{&d.d}.uint64(d.decInteger())
+	d.bdRead = false
+	return
+}
+
+func (d *simpleDecDriver) DecodeFloat64() (f float64) {
+	if d.advanceNil() {
+		return
+	}
+	f = decNegintPosintFloatNumberHelper{&d.d}.float64(d.decFloat())
+	d.bdRead = false
+	return
+}
+
+// bool can be decoded from bool only (single byte).
+func (d *simpleDecDriver) DecodeBool() (b bool) {
+	if d.advanceNil() {
+		return
+	}
+	if d.bd == simpleVdFalse {
+	} else if d.bd == simpleVdTrue {
+		b = true
+	} else {
+		d.d.errorf("cannot decode bool - %s: %x", msgBadDesc, d.bd)
+	}
+	d.bdRead = false
+	return
+}
+
+func (d *simpleDecDriver) ReadMapStart() (length int) {
+	if d.advanceNil() {
+		return containerLenNil
+	}
+	d.bdRead = false
+	return d.decLen()
+}
+
+func (d *simpleDecDriver) ReadArrayStart() (length int) {
+	if d.advanceNil() {
+		return containerLenNil
+	}
+	d.bdRead = false
+	return d.decLen()
+}
+
+func (d *simpleDecDriver) uint2Len(ui uint64) int {
+	if chkOvf.Uint(ui, intBitsize) {
+		d.d.errorf("overflow integer: %v", ui)
+	}
+	return int(ui)
+}
+
+func (d *simpleDecDriver) decLen() int {
+	switch d.bd & 7 { // d.bd % 8 {
+	case 0:
+		return 0
+	case 1:
+		return int(d.d.decRd.readn1())
+	case 2:
+		return int(bigen.Uint16(d.d.decRd.readn2()))
+	case 3:
+		return d.uint2Len(uint64(bigen.Uint32(d.d.decRd.readn4())))
+	case 4:
+		return d.uint2Len(bigen.Uint64(d.d.decRd.readn8()))
+	}
+	d.d.errorf("cannot read length: bd%%8 must be in range 0..4. Got: %d", d.bd%8)
+	return -1
+}
+
+func (d *simpleDecDriver) DecodeStringAsBytes() (s []byte) {
+	return d.DecodeBytes(nil)
+}
+
+func (d *simpleDecDriver) DecodeBytes(bs []byte) (bsOut []byte) {
+	d.d.decByteState = decByteStateNone
+	if d.advanceNil() {
+		return
+	}
+	// check if an "array" of uint8's (see ContainerType for how to infer if an array)
+	if d.bd >= simpleVdArray && d.bd <= simpleVdMap+4 {
+		if bs == nil {
+			d.d.decByteState = decByteStateReuseBuf
+			bs = d.d.b[:]
+		}
+		slen := d.ReadArrayStart()
+		var changed bool
+		if bs, changed = usableByteSlice(bs, slen); changed {
+			d.d.decByteState = decByteStateNone
+		}
+		for i := 0; i < len(bs); i++ {
+			bs[i] = uint8(chkOvf.UintV(d.DecodeUint64(), 8))
+		}
+		return bs
+	}
+
+	clen := d.decLen()
+	d.bdRead = false
+	if d.d.zerocopy() {
+		d.d.decByteState = decByteStateZerocopy
+		return d.d.decRd.rb.readx(uint(clen))
+	}
+	if bs == nil {
+		d.d.decByteState = decByteStateReuseBuf
+		bs = d.d.b[:]
+	}
+	return decByteSlice(d.d.r(), clen, d.d.h.MaxInitLen, bs)
+}
+
+func (d *simpleDecDriver) DecodeTime() (t time.Time) {
+	if d.advanceNil() {
+		return
+	}
+	if d.bd != simpleVdTime {
+		d.d.errorf("invalid descriptor for time.Time - expect 0x%x, received 0x%x", simpleVdTime, d.bd)
+	}
+	d.bdRead = false
+	clen := uint(d.d.decRd.readn1())
+	b := d.d.decRd.readx(clen)
+	d.d.onerror((&t).UnmarshalBinary(b))
+	return
+}
+
+func (d *simpleDecDriver) DecodeExt(rv interface{}, basetype reflect.Type, xtag uint64, ext Ext) {
+	if xtag > 0xff {
+		d.d.errorf("ext: tag must be <= 0xff; got: %v", xtag)
+	}
+	if d.advanceNil() {
+		return
+	}
+	xbs, realxtag1, zerocopy := d.decodeExtV(ext != nil, uint8(xtag))
+	realxtag := uint64(realxtag1)
+	if ext == nil {
+		re := rv.(*RawExt)
+		re.Tag = realxtag
+		re.setData(xbs, zerocopy)
+	} else if ext == SelfExt {
+		d.d.sideDecode(rv, basetype, xbs)
+	} else {
+		ext.ReadExt(rv, xbs)
+	}
+}
+
+func (d *simpleDecDriver) decodeExtV(verifyTag bool, tag byte) (xbs []byte, xtag byte, zerocopy bool) {
+	switch d.bd {
+	case simpleVdExt, simpleVdExt + 1, simpleVdExt + 2, simpleVdExt + 3, simpleVdExt + 4:
+		l := d.decLen()
+		xtag = d.d.decRd.readn1()
+		if verifyTag && xtag != tag {
+			d.d.errorf("wrong extension tag. Got %b. Expecting: %v", xtag, tag)
+		}
+		if d.d.bytes {
+			xbs = d.d.decRd.rb.readx(uint(l))
+			zerocopy = true
+		} else {
+			xbs = decByteSlice(d.d.r(), l, d.d.h.MaxInitLen, d.d.b[:])
+		}
+	case simpleVdByteArray, simpleVdByteArray + 1,
+		simpleVdByteArray + 2, simpleVdByteArray + 3, simpleVdByteArray + 4:
+		xbs = d.DecodeBytes(nil)
+	default:
+		d.d.errorf("ext - %s - expecting extensions/bytearray, got: 0x%x", msgBadDesc, d.bd)
+	}
+	d.bdRead = false
+	return
+}
+
+func (d *simpleDecDriver) DecodeNaked() {
+	if !d.bdRead {
+		d.readNextBd()
+	}
+
+	n := d.d.naked()
+	var decodeFurther bool
+
+	switch d.bd {
+	case simpleVdNil:
+		n.v = valueTypeNil
+	case simpleVdFalse:
+		n.v = valueTypeBool
+		n.b = false
+	case simpleVdTrue:
+		n.v = valueTypeBool
+		n.b = true
+	case simpleVdPosInt, simpleVdPosInt + 1, simpleVdPosInt + 2, simpleVdPosInt + 3:
+		if d.h.SignedInteger {
+			n.v = valueTypeInt
+			n.i = d.DecodeInt64()
+		} else {
+			n.v = valueTypeUint
+			n.u = d.DecodeUint64()
+		}
+	case simpleVdNegInt, simpleVdNegInt + 1, simpleVdNegInt + 2, simpleVdNegInt + 3:
+		n.v = valueTypeInt
+		n.i = d.DecodeInt64()
+	case simpleVdFloat32:
+		n.v = valueTypeFloat
+		n.f = d.DecodeFloat64()
+	case simpleVdFloat64:
+		n.v = valueTypeFloat
+		n.f = d.DecodeFloat64()
+	case simpleVdTime:
+		n.v = valueTypeTime
+		n.t = d.DecodeTime()
+	case simpleVdString, simpleVdString + 1,
+		simpleVdString + 2, simpleVdString + 3, simpleVdString + 4:
+		n.v = valueTypeString
+		n.s = d.d.stringZC(d.DecodeStringAsBytes())
+	case simpleVdByteArray, simpleVdByteArray + 1,
+		simpleVdByteArray + 2, simpleVdByteArray + 3, simpleVdByteArray + 4:
+		d.d.fauxUnionReadRawBytes(false)
+	case simpleVdExt, simpleVdExt + 1, simpleVdExt + 2, simpleVdExt + 3, simpleVdExt + 4:
+		n.v = valueTypeExt
+		l := d.decLen()
+		n.u = uint64(d.d.decRd.readn1())
+		if d.d.bytes {
+			n.l = d.d.decRd.rb.readx(uint(l))
+		} else {
+			n.l = decByteSlice(d.d.r(), l, d.d.h.MaxInitLen, d.d.b[:])
+		}
+	case simpleVdArray, simpleVdArray + 1, simpleVdArray + 2,
+		simpleVdArray + 3, simpleVdArray + 4:
+		n.v = valueTypeArray
+		decodeFurther = true
+	case simpleVdMap, simpleVdMap + 1, simpleVdMap + 2, simpleVdMap + 3, simpleVdMap + 4:
+		n.v = valueTypeMap
+		decodeFurther = true
+	default:
+		d.d.errorf("cannot infer value - %s 0x%x", msgBadDesc, d.bd)
+	}
+
+	if !decodeFurther {
+		d.bdRead = false
+	}
+}
+
+func (d *simpleDecDriver) nextValueBytes(v0 []byte) (v []byte) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
+	v = v0
+	var h = decNextValueBytesHelper{d: &d.d}
+	var cursor = d.d.rb.c - 1
+	h.append1(&v, d.bd)
+	v = d.nextValueBytesBdReadR(v)
+	d.bdRead = false
+	h.bytesRdV(&v, cursor)
+	return
+}
+
+func (d *simpleDecDriver) nextValueBytesR(v0 []byte) (v []byte) {
+	d.readNextBd()
+	v = v0
+	var h = decNextValueBytesHelper{d: &d.d}
+	h.append1(&v, d.bd)
+	return d.nextValueBytesBdReadR(v)
+}
+
+func (d *simpleDecDriver) nextValueBytesBdReadR(v0 []byte) (v []byte) {
+	v = v0
+	var h = decNextValueBytesHelper{d: &d.d}
+
+	c := d.bd
+
+	var length uint
+
+	switch c {
+	case simpleVdNil, simpleVdFalse, simpleVdTrue, simpleVdString, simpleVdByteArray:
+		// pass
+	case simpleVdPosInt, simpleVdNegInt:
+		h.append1(&v, d.d.decRd.readn1())
+	case simpleVdPosInt + 1, simpleVdNegInt + 1:
+		h.appendN(&v, d.d.decRd.readx(2)...)
+	case simpleVdPosInt + 2, simpleVdNegInt + 2, simpleVdFloat32:
+		h.appendN(&v, d.d.decRd.readx(4)...)
+	case simpleVdPosInt + 3, simpleVdNegInt + 3, simpleVdFloat64:
+		h.appendN(&v, d.d.decRd.readx(8)...)
+	case simpleVdTime:
+		c = d.d.decRd.readn1()
+		h.append1(&v, c)
+		h.appendN(&v, d.d.decRd.readx(uint(c))...)
+
+	default:
+		switch c & 7 { // c % 8 {
+		case 0:
+			length = 0
+		case 1:
+			b := d.d.decRd.readn1()
+			length = uint(b)
+			h.append1(&v, b)
+		case 2:
+			x := d.d.decRd.readn2()
+			length = uint(bigen.Uint16(x))
+			h.appendN(&v, x[:]...)
+		case 3:
+			x := d.d.decRd.readn4()
+			length = uint(bigen.Uint32(x))
+			h.appendN(&v, x[:]...)
+		case 4:
+			x := d.d.decRd.readn8()
+			length = uint(bigen.Uint64(x))
+			h.appendN(&v, x[:]...)
+		}
+
+		bExt := c >= simpleVdExt && c <= simpleVdExt+7
+		bStr := c >= simpleVdString && c <= simpleVdString+7
+		bByteArray := c >= simpleVdByteArray && c <= simpleVdByteArray+7
+		bArray := c >= simpleVdArray && c <= simpleVdArray+7
+		bMap := c >= simpleVdMap && c <= simpleVdMap+7
+
+		if !(bExt || bStr || bByteArray || bArray || bMap) {
+			d.d.errorf("cannot infer value - %s 0x%x", msgBadDesc, c)
+		}
+
+		if bExt {
+			h.append1(&v, d.d.decRd.readn1()) // tag
+		}
+
+		if length == 0 {
+			break
+		}
+
+		if bArray {
+			for i := uint(0); i < length; i++ {
+				v = d.nextValueBytesR(v)
+			}
+		} else if bMap {
+			for i := uint(0); i < length; i++ {
+				v = d.nextValueBytesR(v)
+				v = d.nextValueBytesR(v)
+			}
+		} else {
+			h.appendN(&v, d.d.decRd.readx(length)...)
+		}
+	}
+	return
+}
+
+//------------------------------------
+
+// SimpleHandle is a Handle for a very simple encoding format.
+//
+// simple is a simplistic codec similar to binc, but not as compact.
+//   - Encoding of a value is always preceded by the descriptor byte (bd)
+//   - True, false, nil are encoded fully in 1 byte (the descriptor)
+//   - Integers (intXXX, uintXXX) are encoded in 1, 2, 4 or 8 bytes (plus a descriptor byte).
+//     There are positive (uintXXX and intXXX >= 0) and negative (intXXX < 0) integers.
+//   - Floats are encoded in 4 or 8 bytes (plus a descriptor byte)
+//   - Length of containers (strings, bytes, array, map, extensions)
+//     are encoded in 0, 1, 2, 4 or 8 bytes.
+//     Zero-length containers have no length encoded.
+//     For others, the number of bytes is given by pow(2, bd%3)
+//   - maps are encoded as [bd] [length] [[key][value]]...
+//   - arrays are encoded as [bd] [length] [value]...
+//   - extensions are encoded as [bd] [length] [tag] [byte]...
+//   - strings/bytearrays are encoded as [bd] [length] [byte]...
+//   - time.Time are encoded as [bd] [length] [byte]...
+//
+// The full spec will be published soon.
+type SimpleHandle struct {
+	binaryEncodingType
+	BasicHandle
+	// EncZeroValuesAsNil says to encode zero values for numbers, bool, string, etc as nil
+	EncZeroValuesAsNil bool
+}
+
+// Name returns the name of the handle: simple
+func (h *SimpleHandle) Name() string { return "simple" }
+
+func (h *SimpleHandle) desc(bd byte) string { return simpledesc(bd) }
+
+func (h *SimpleHandle) newEncDriver() encDriver {
+	var e = &simpleEncDriver{h: h}
+	e.e.e = e
+	e.e.init(h)
+	e.reset()
+	return e
+}
+
+func (h *SimpleHandle) newDecDriver() decDriver {
+	d := &simpleDecDriver{h: h}
+	d.d.d = d
+	d.d.init(h)
+	d.reset()
+	return d
+}
+
+var _ decDriver = (*simpleDecDriver)(nil)
+var _ encDriver = (*simpleEncDriver)(nil)

vendor/github.com/ugorji/go/codec/sort-slice.generated.go

@@ -0,0 +1,158 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+// Code generated from sort-slice.go.tmpl - DO NOT EDIT.
+
+package codec
+
+import "time"
+import "reflect"
+import "bytes"
+
+type stringSlice []string
+
+func (p stringSlice) Len() int      { return len(p) }
+func (p stringSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
+func (p stringSlice) Less(i, j int) bool {
+	return p[uint(i)] < p[uint(j)]
+}
+
+type uint8Slice []uint8
+
+func (p uint8Slice) Len() int      { return len(p) }
+func (p uint8Slice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
+func (p uint8Slice) Less(i, j int) bool {
+	return p[uint(i)] < p[uint(j)]
+}
+
+type uint64Slice []uint64
+
+func (p uint64Slice) Len() int      { return len(p) }
+func (p uint64Slice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
+func (p uint64Slice) Less(i, j int) bool {
+	return p[uint(i)] < p[uint(j)]
+}
+
+type intSlice []int
+
+func (p intSlice) Len() int      { return len(p) }
+func (p intSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
+func (p intSlice) Less(i, j int) bool {
+	return p[uint(i)] < p[uint(j)]
+}
+
+type int32Slice []int32
+
+func (p int32Slice) Len() int      { return len(p) }
+func (p int32Slice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
+func (p int32Slice) Less(i, j int) bool {
+	return p[uint(i)] < p[uint(j)]
+}
+
+type stringRv struct {
+	v string
+	r reflect.Value
+}
+type stringRvSlice []stringRv
+
+func (p stringRvSlice) Len() int      { return len(p) }
+func (p stringRvSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
+func (p stringRvSlice) Less(i, j int) bool {
+	return p[uint(i)].v < p[uint(j)].v
+}
+
+type stringIntf struct {
+	v string
+	i interface{}
+}
+type stringIntfSlice []stringIntf
+
+func (p stringIntfSlice) Len() int      { return len(p) }
+func (p stringIntfSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
+func (p stringIntfSlice) Less(i, j int) bool {
+	return p[uint(i)].v < p[uint(j)].v
+}
+
+type float64Rv struct {
+	v float64
+	r reflect.Value
+}
+type float64RvSlice []float64Rv
+
+func (p float64RvSlice) Len() int      { return len(p) }
+func (p float64RvSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
+func (p float64RvSlice) Less(i, j int) bool {
+	return p[uint(i)].v < p[uint(j)].v || isNaN64(p[uint(i)].v) && !isNaN64(p[uint(j)].v)
+}
+
+type uint64Rv struct {
+	v uint64
+	r reflect.Value
+}
+type uint64RvSlice []uint64Rv
+
+func (p uint64RvSlice) Len() int      { return len(p) }
+func (p uint64RvSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
+func (p uint64RvSlice) Less(i, j int) bool {
+	return p[uint(i)].v < p[uint(j)].v
+}
+
+type int64Rv struct {
+	v int64
+	r reflect.Value
+}
+type int64RvSlice []int64Rv
+
+func (p int64RvSlice) Len() int      { return len(p) }
+func (p int64RvSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
+func (p int64RvSlice) Less(i, j int) bool {
+	return p[uint(i)].v < p[uint(j)].v
+}
+
+type boolRv struct {
+	v bool
+	r reflect.Value
+}
+type boolRvSlice []boolRv
+
+func (p boolRvSlice) Len() int      { return len(p) }
+func (p boolRvSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
+func (p boolRvSlice) Less(i, j int) bool {
+	return !p[uint(i)].v && p[uint(j)].v
+}
+
+type timeRv struct {
+	v time.Time
+	r reflect.Value
+}
+type timeRvSlice []timeRv
+
+func (p timeRvSlice) Len() int      { return len(p) }
+func (p timeRvSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
+func (p timeRvSlice) Less(i, j int) bool {
+	return p[uint(i)].v.Before(p[uint(j)].v)
+}
+
+type bytesRv struct {
+	v []byte
+	r reflect.Value
+}
+type bytesRvSlice []bytesRv
+
+func (p bytesRvSlice) Len() int      { return len(p) }
+func (p bytesRvSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
+func (p bytesRvSlice) Less(i, j int) bool {
+	return bytes.Compare(p[uint(i)].v, p[uint(j)].v) == -1
+}
+
+type bytesIntf struct {
+	v []byte
+	i interface{}
+}
+type bytesIntfSlice []bytesIntf
+
+func (p bytesIntfSlice) Len() int      { return len(p) }
+func (p bytesIntfSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
+func (p bytesIntfSlice) Less(i, j int) bool {
+	return bytes.Compare(p[uint(i)].v, p[uint(j)].v) == -1
+}

vendor/github.com/ugorji/go/codec/sort-slice.go.tmpl

@@ -0,0 +1,66 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+// Code generated from sort-slice.go.tmpl - DO NOT EDIT.
+
+{{/*
+xxxSlice
+xxxIntf
+xxxIntfSlice
+xxxRv
+xxxRvSlice
+
+I'm now going to create them for
+- sortables
+- sortablesplus
+
+With the parameters passed in sortables or sortablesplus,
+'time, 'bytes' are special, and correspond to time.Time and []byte respectively.
+*/}}
+
+package codec
+
+import "time"
+import "reflect"
+import "bytes"
+
+{{/* func init() { _ = time.Unix } */}}
+
+{{define "T"}}
+func (p {{ .Type }}) Len() int           { return len(p) }
+func (p {{ .Type }}) Swap(i, j int)      { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
+func (p {{ .Type }}) Less(i, j int) bool {
+	{{ if eq .Kind "bool"         }} return !p[uint(i)]{{.V}} && p[uint(j)]{{.V}}
+    {{ else if eq .Kind "float32" }} return p[uint(i)]{{.V}} < p[uint(j)]{{.V}} || isNaN32(p[uint(i)]{{.V}}) && !isNaN32(p[uint(j)]{{.V}})
+    {{ else if eq .Kind "float64" }} return p[uint(i)]{{.V}} < p[uint(j)]{{.V}} || isNaN64(p[uint(i)]{{.V}}) && !isNaN64(p[uint(j)]{{.V}})
+    {{ else if eq .Kind "time"    }} return p[uint(i)]{{.V}}.Before(p[uint(j)]{{.V}})
+    {{ else if eq .Kind "bytes"   }} return bytes.Compare(p[uint(i)]{{.V}}, p[uint(j)]{{.V}}) == -1
+    {{ else                    }} return p[uint(i)]{{.V}} < p[uint(j)]{{.V}}
+    {{ end -}}
+}
+{{end}}
+
+{{range $i, $v := sortables }}{{ $t := tshort $v }}
+type {{ $v }}Slice []{{ $t }}
+{{template "T" args "Kind" $v "Type" (print $v "Slice") "V" ""}}
+{{end}}
+
+{{range $i, $v := sortablesplus }}{{ $t := tshort $v }}
+
+type {{ $v }}Rv struct {
+	v {{ $t }}
+	r reflect.Value
+}
+type {{ $v }}RvSlice []{{ $v }}Rv
+{{template "T" args "Kind" $v "Type" (print $v "RvSlice") "V" ".v"}}
+
+{{if eq $v "bytes" "string" -}}
+type {{ $v }}Intf struct {
+	v {{ $t }}
+	i interface{}
+}
+type {{ $v }}IntfSlice []{{ $v }}Intf
+{{template "T" args "Kind" $v "Type" (print $v "IntfSlice") "V" ".v"}}
+{{end}}
+
+{{end}}

vendor/github.com/ugorji/go/codec/test-cbor-goldens.json

@@ -0,0 +1,639 @@
+[
+  {
+    "cbor": "AA==",
+    "hex": "00",
+    "roundtrip": true,
+    "decoded": 0
+  },
+  {
+    "cbor": "AQ==",
+    "hex": "01",
+    "roundtrip": true,
+    "decoded": 1
+  },
+  {
+    "cbor": "Cg==",
+    "hex": "0a",
+    "roundtrip": true,
+    "decoded": 10
+  },
+  {
+    "cbor": "Fw==",
+    "hex": "17",
+    "roundtrip": true,
+    "decoded": 23
+  },
+  {
+    "cbor": "GBg=",
+    "hex": "1818",
+    "roundtrip": true,
+    "decoded": 24
+  },
+  {
+    "cbor": "GBk=",
+    "hex": "1819",
+    "roundtrip": true,
+    "decoded": 25
+  },
+  {
+    "cbor": "GGQ=",
+    "hex": "1864",
+    "roundtrip": true,
+    "decoded": 100
+  },
+  {
+    "cbor": "GQPo",
+    "hex": "1903e8",
+    "roundtrip": true,
+    "decoded": 1000
+  },
+  {
+    "cbor": "GgAPQkA=",
+    "hex": "1a000f4240",
+    "roundtrip": true,
+    "decoded": 1000000
+  },
+  {
+    "cbor": "GwAAAOjUpRAA",
+    "hex": "1b000000e8d4a51000",
+    "roundtrip": true,
+    "decoded": 1000000000000
+  },
+  {
+    "cbor": "G///////////",
+    "hex": "1bffffffffffffffff",
+    "roundtrip": true,
+    "decoded": 18446744073709551615
+  },
+  {
+    "cbor": "wkkBAAAAAAAAAAA=",
+    "hex": "c249010000000000000000",
+    "roundtrip": true,
+    "decoded": 18446744073709551616
+  },
+  {
+    "cbor": "O///////////",
+    "hex": "3bffffffffffffffff",
+    "roundtrip": true,
+    "decoded": -18446744073709551616,
+    "skip": true
+  },
+  {
+    "cbor": "w0kBAAAAAAAAAAA=",
+    "hex": "c349010000000000000000",
+    "roundtrip": true,
+    "decoded": -18446744073709551617
+  },
+  {
+    "cbor": "IA==",
+    "hex": "20",
+    "roundtrip": true,
+    "decoded": -1
+  },
+  {
+    "cbor": "KQ==",
+    "hex": "29",
+    "roundtrip": true,
+    "decoded": -10
+  },
+  {
+    "cbor": "OGM=",
+    "hex": "3863",
+    "roundtrip": true,
+    "decoded": -100
+  },
+  {
+    "cbor": "OQPn",
+    "hex": "3903e7",
+    "roundtrip": true,
+    "decoded": -1000
+  },
+  {
+    "cbor": "+QAA",
+    "hex": "f90000",
+    "roundtrip": true,
+    "decoded": 0.0
+  },
+  {
+    "cbor": "+YAA",
+    "hex": "f98000",
+    "roundtrip": true,
+    "decoded": -0.0
+  },
+  {
+    "cbor": "+TwA",
+    "hex": "f93c00",
+    "roundtrip": true,
+    "decoded": 1.0
+  },
+  {
+    "cbor": "+z/xmZmZmZma",
+    "hex": "fb3ff199999999999a",
+    "roundtrip": true,
+    "decoded": 1.1
+  },
+  {
+    "cbor": "+T4A",
+    "hex": "f93e00",
+    "roundtrip": true,
+    "decoded": 1.5
+  },
+  {
+    "cbor": "+Xv/",
+    "hex": "f97bff",
+    "roundtrip": true,
+    "decoded": 65504.0
+  },
+  {
+    "cbor": "+kfDUAA=",
+    "hex": "fa47c35000",
+    "roundtrip": true,
+    "decoded": 100000.0
+  },
+  {
+    "cbor": "+n9///8=",
+    "hex": "fa7f7fffff",
+    "roundtrip": true,
+    "decoded": 3.4028234663852886e+38
+  },
+  {
+    "cbor": "+3435DyIAHWc",
+    "hex": "fb7e37e43c8800759c",
+    "roundtrip": true,
+    "decoded": 1.0e+300
+  },
+  {
+    "cbor": "+QAB",
+    "hex": "f90001",
+    "roundtrip": true,
+    "decoded": 5.960464477539063e-08
+  },
+  {
+    "cbor": "+QQA",
+    "hex": "f90400",
+    "roundtrip": true,
+    "decoded": 6.103515625e-05
+  },
+  {
+    "cbor": "+cQA",
+    "hex": "f9c400",
+    "roundtrip": true,
+    "decoded": -4.0
+  },
+  {
+    "cbor": "+8AQZmZmZmZm",
+    "hex": "fbc010666666666666",
+    "roundtrip": true,
+    "decoded": -4.1
+  },
+  {
+    "cbor": "+XwA",
+    "hex": "f97c00",
+    "roundtrip": true,
+    "diagnostic": "Infinity"
+  },
+  {
+    "cbor": "+X4A",
+    "hex": "f97e00",
+    "roundtrip": true,
+    "diagnostic": "NaN"
+  },
+  {
+    "cbor": "+fwA",
+    "hex": "f9fc00",
+    "roundtrip": true,
+    "diagnostic": "-Infinity"
+  },
+  {
+    "cbor": "+n+AAAA=",
+    "hex": "fa7f800000",
+    "roundtrip": false,
+    "diagnostic": "Infinity"
+  },
+  {
+    "cbor": "+n/AAAA=",
+    "hex": "fa7fc00000",
+    "roundtrip": false,
+    "diagnostic": "NaN"
+  },
+  {
+    "cbor": "+v+AAAA=",
+    "hex": "faff800000",
+    "roundtrip": false,
+    "diagnostic": "-Infinity"
+  },
+  {
+    "cbor": "+3/wAAAAAAAA",
+    "hex": "fb7ff0000000000000",
+    "roundtrip": false,
+    "diagnostic": "Infinity"
+  },
+  {
+    "cbor": "+3/4AAAAAAAA",
+    "hex": "fb7ff8000000000000",
+    "roundtrip": false,
+    "diagnostic": "NaN"
+  },
+  {
+    "cbor": "+//wAAAAAAAA",
+    "hex": "fbfff0000000000000",
+    "roundtrip": false,
+    "diagnostic": "-Infinity"
+  },
+  {
+    "cbor": "9A==",
+    "hex": "f4",
+    "roundtrip": true,
+    "decoded": false
+  },
+  {
+    "cbor": "9Q==",
+    "hex": "f5",
+    "roundtrip": true,
+    "decoded": true
+  },
+  {
+    "cbor": "9g==",
+    "hex": "f6",
+    "roundtrip": true,
+    "decoded": null
+  },
+  {
+    "cbor": "9w==",
+    "hex": "f7",
+    "roundtrip": true,
+    "diagnostic": "undefined"
+  },
+  {
+    "cbor": "8A==",
+    "hex": "f0",
+    "roundtrip": true,
+    "diagnostic": "simple(16)"
+  },
+  {
+    "cbor": "+Bg=",
+    "hex": "f818",
+    "roundtrip": true,
+    "diagnostic": "simple(24)"
+  },
+  {
+    "cbor": "+P8=",
+    "hex": "f8ff",
+    "roundtrip": true,
+    "diagnostic": "simple(255)"
+  },
+  {
+    "cbor": "wHQyMDEzLTAzLTIxVDIwOjA0OjAwWg==",
+    "hex": "c074323031332d30332d32315432303a30343a30305a",
+    "roundtrip": true,
+    "diagnostic": "0(\"2013-03-21T20:04:00Z\")"
+  },
+  {
+    "cbor": "wRpRS2ew",
+    "hex": "c11a514b67b0",
+    "roundtrip": true,
+    "diagnostic": "1(1363896240)"
+  },
+  {
+    "cbor": "wftB1FLZ7CAAAA==",
+    "hex": "c1fb41d452d9ec200000",
+    "roundtrip": true,
+    "diagnostic": "1(1363896240.5)"
+  },
+  {
+    "cbor": "10QBAgME",
+    "hex": "d74401020304",
+    "roundtrip": true,
+    "diagnostic": "23(h'01020304')"
+  },
+  {
+    "cbor": "2BhFZElFVEY=",
+    "hex": "d818456449455446",
+    "roundtrip": true,
+    "diagnostic": "24(h'6449455446')"
+  },
+  {
+    "cbor": "2CB2aHR0cDovL3d3dy5leGFtcGxlLmNvbQ==",
+    "hex": "d82076687474703a2f2f7777772e6578616d706c652e636f6d",
+    "roundtrip": true,
+    "diagnostic": "32(\"http://www.example.com\")"
+  },
+  {
+    "cbor": "QA==",
+    "hex": "40",
+    "roundtrip": true,
+    "diagnostic": "h''"
+  },
+  {
+    "cbor": "RAECAwQ=",
+    "hex": "4401020304",
+    "roundtrip": true,
+    "diagnostic": "h'01020304'"
+  },
+  {
+    "cbor": "YA==",
+    "hex": "60",
+    "roundtrip": true,
+    "decoded": ""
+  },
+  {
+    "cbor": "YWE=",
+    "hex": "6161",
+    "roundtrip": true,
+    "decoded": "a"
+  },
+  {
+    "cbor": "ZElFVEY=",
+    "hex": "6449455446",
+    "roundtrip": true,
+    "decoded": "IETF"
+  },
+  {
+    "cbor": "YiJc",
+    "hex": "62225c",
+    "roundtrip": true,
+    "decoded": "\"\\"
+  },
+  {
+    "cbor": "YsO8",
+    "hex": "62c3bc",
+    "roundtrip": true,
+    "decoded": "ü"
+  },
+  {
+    "cbor": "Y+awtA==",
+    "hex": "63e6b0b4",
+    "roundtrip": true,
+    "decoded": "水"
+  },
+  {
+    "cbor": "ZPCQhZE=",
+    "hex": "64f0908591",
+    "roundtrip": true,
+    "decoded": "𐅑"
+  },
+  {
+    "cbor": "gA==",
+    "hex": "80",
+    "roundtrip": true,
+    "decoded": [
+
+    ]
+  },
+  {
+    "cbor": "gwECAw==",
+    "hex": "83010203",
+    "roundtrip": true,
+    "decoded": [
+      1,
+      2,
+      3
+    ]
+  },
+  {
+    "cbor": "gwGCAgOCBAU=",
+    "hex": "8301820203820405",
+    "roundtrip": true,
+    "decoded": [
+      1,
+      [
+        2,
+        3
+      ],
+      [
+        4,
+        5
+      ]
+    ]
+  },
+  {
+    "cbor": "mBkBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgYGBk=",
+    "hex": "98190102030405060708090a0b0c0d0e0f101112131415161718181819",
+    "roundtrip": true,
+    "decoded": [
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19,
+      20,
+      21,
+      22,
+      23,
+      24,
+      25
+    ]
+  },
+  {
+    "cbor": "oA==",
+    "hex": "a0",
+    "roundtrip": true,
+    "decoded": {
+    }
+  },
+  {
+    "cbor": "ogECAwQ=",
+    "hex": "a201020304",
+    "roundtrip": true,
+    "skip": true,
+    "diagnostic": "{1: 2, 3: 4}"
+  },
+  {
+    "cbor": "omFhAWFiggID",
+    "hex": "a26161016162820203",
+    "roundtrip": true,
+    "decoded": {
+      "a": 1,
+      "b": [
+        2,
+        3
+      ]
+    }
+  },
+  {
+    "cbor": "gmFhoWFiYWM=",
+    "hex": "826161a161626163",
+    "roundtrip": true,
+    "decoded": [
+      "a",
+      {
+        "b": "c"
+      }
+    ]
+  },
+  {
+    "cbor": "pWFhYUFhYmFCYWNhQ2FkYURhZWFF",
+    "hex": "a56161614161626142616361436164614461656145",
+    "roundtrip": true,
+    "decoded": {
+      "a": "A",
+      "b": "B",
+      "c": "C",
+      "d": "D",
+      "e": "E"
+    }
+  },
+  {
+    "cbor": "X0IBAkMDBAX/",
+    "hex": "5f42010243030405ff",
+    "roundtrip": false,
+    "skip": true,
+    "diagnostic": "(_ h'0102', h'030405')"
+  },
+  {
+    "cbor": "f2VzdHJlYWRtaW5n/w==",
+    "hex": "7f657374726561646d696e67ff",
+    "roundtrip": false,
+    "decoded": "streaming"
+  },
+  {
+    "cbor": "n/8=",
+    "hex": "9fff",
+    "roundtrip": false,
+    "decoded": [
+
+    ]
+  },
+  {
+    "cbor": "nwGCAgOfBAX//w==",
+    "hex": "9f018202039f0405ffff",
+    "roundtrip": false,
+    "decoded": [
+      1,
+      [
+        2,
+        3
+      ],
+      [
+        4,
+        5
+      ]
+    ]
+  },
+  {
+    "cbor": "nwGCAgOCBAX/",
+    "hex": "9f01820203820405ff",
+    "roundtrip": false,
+    "decoded": [
+      1,
+      [
+        2,
+        3
+      ],
+      [
+        4,
+        5
+      ]
+    ]
+  },
+  {
+    "cbor": "gwGCAgOfBAX/",
+    "hex": "83018202039f0405ff",
+    "roundtrip": false,
+    "decoded": [
+      1,
+      [
+        2,
+        3
+      ],
+      [
+        4,
+        5
+      ]
+    ]
+  },
+  {
+    "cbor": "gwGfAgP/ggQF",
+    "hex": "83019f0203ff820405",
+    "roundtrip": false,
+    "decoded": [
+      1,
+      [
+        2,
+        3
+      ],
+      [
+        4,
+        5
+      ]
+    ]
+  },
+  {
+    "cbor": "nwECAwQFBgcICQoLDA0ODxAREhMUFRYXGBgYGf8=",
+    "hex": "9f0102030405060708090a0b0c0d0e0f101112131415161718181819ff",
+    "roundtrip": false,
+    "decoded": [
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19,
+      20,
+      21,
+      22,
+      23,
+      24,
+      25
+    ]
+  },
+  {
+    "cbor": "v2FhAWFinwID//8=",
+    "hex": "bf61610161629f0203ffff",
+    "roundtrip": false,
+    "decoded": {
+      "a": 1,
+      "b": [
+        2,
+        3
+      ]
+    }
+  },
+  {
+    "cbor": "gmFhv2FiYWP/",
+    "hex": "826161bf61626163ff",
+    "roundtrip": false,
+    "decoded": [
+      "a",
+      {
+        "b": "c"
+      }
+    ]
+  },
+  {
+    "cbor": "v2NGdW71Y0FtdCH/",
+    "hex": "bf6346756ef563416d7421ff",
+    "roundtrip": false,
+    "decoded": {
+      "Fun": true,
+      "Amt": -2
+    }
+  }
+]

vendor/github.com/ugorji/go/codec/test.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python
+
+# This will create golden files in a directory passed to it.
+# A Test calls this internally to create the golden files
+# So it can process them (so we don't have to checkin the files).
+
+# Ensure msgpack-python and cbor are installed first, using:
+#   sudo apt install python-dev (may not be necessary)
+#   sudo apt install python-pip # or python3-pip
+#   pip install --user msgpack-python msgpack-rpc-python cbor
+
+# Ensure all "string" keys are utf strings (else encoded as bytes)
+
+from __future__ import print_function
+import cbor, msgpack, msgpackrpc, sys, os, threading
+
+mylocaladdr="127.0.0.1" # localhost.localdomain localhost 127.0.0.1
+
+def get_test_data_list():
+    # get list with all primitive types, and a combo type
+    l0 = [ 
+        -8,
+         -1616,
+         -32323232,
+         -6464646464646464,
+         192,
+         1616,
+         32323232,
+         6464646464646464,
+         192,
+         -3232.0,
+         -6464646464.0,
+         3232.0,
+         6464.0,
+         6464646464.0,
+         160.0,
+         1616.0,
+         False,
+         True,
+         u"null",
+         None,
+         u"some&day>some<day",
+         1328176922000002000,
+         u"",
+         -2206187877999998000,
+         u"bytestring",
+         270,
+         u"none",
+        -2013855847999995777,
+         #-6795364578871345152,
+         ]
+    l1 = [
+        { "true": True,
+          "false": False },
+        { "true": u"True",
+          "false": False,
+          "uint16(1616)": 1616 },
+        { "list": [1616, 32323232, True, -3232.0, {"TRUE":True, "FALSE":False}, [True, False] ],
+          "int32":32323232, "bool": True, 
+          "LONG STRING": u"123456789012345678901234567890123456789012345678901234567890",
+          "SHORT STRING": u"1234567890" },
+        { True: "true", 138: False, "false": 200 }
+        ]
+    
+    l = []
+    l.extend(l0)
+    l.append(l0)
+    l.append(1)
+    l.extend(l1)
+    return l
+
+def build_test_data(destdir):
+    l = get_test_data_list()
+    for i in range(len(l)):
+        # packer = msgpack.Packer()
+        serialized = msgpack.dumps(l[i])
+        with open(os.path.join(destdir, str(i) + '.msgpack.golden'), 'wb') as f:
+            f.write(serialized)
+        serialized = cbor.dumps(l[i])
+        with open(os.path.join(destdir, str(i) + '.cbor.golden'), 'wb') as f:
+            f.write(serialized)
+
+def doRpcServer(port, stopTimeSec):
+    class EchoHandler(object):
+        def Echo123(self, msg1, msg2, msg3):
+            return ("1:%s 2:%s 3:%s" % (msg1.decode("utf-8"), msg2.decode("utf-8"), msg3.decode("utf-8")))
+        def EchoStruct(self, msg):
+            return ("%s" % msg)
+    
+    addr = msgpackrpc.Address(mylocaladdr, port)
+    server = msgpackrpc.Server(EchoHandler())
+    server.listen(addr)
+    # run thread to stop it after stopTimeSec seconds if > 0
+    if stopTimeSec > 0:
+        def myStopRpcServer():
+            server.stop()
+        t = threading.Timer(stopTimeSec, myStopRpcServer)
+        t.start()
+    server.start()
+
+def doRpcClientToPythonSvc(port):
+    address = msgpackrpc.Address(mylocaladdr, port)
+    client = msgpackrpc.Client(address, unpack_encoding='utf-8')
+    print(client.call("Echo123", "A1", "B2", "C3"))
+    print(client.call("EchoStruct", {"A" :"Aa", "B":"Bb", "C":"Cc"}))
+
+# def doCheckSocket(port):
+#     print(">>>> port: ", port, " <<<<<")
+#     sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+#     result = sock.connect_ex(('127.0.0.1', port))
+#     if result == 0:
+#         print("\t>>>> Port is open")
+#     else:
+#         print("\t>>>> Port is not open")
+#     sock.close()
+    
+def doRpcClientToGoSvc(port):
+    # doCheckSocket(port)
+    address = msgpackrpc.Address(mylocaladdr, port)
+    client = msgpackrpc.Client(address, unpack_encoding='utf-8')
+    print(client.call("TestRpcInt.Echo123", ["A1", "B2", "C3"]))
+    print(client.call("TestRpcInt.EchoStruct", {"A" :"Aa", "B":"Bb", "C":"Cc"}))
+
+def doMain(args):
+    if len(args) == 2 and args[0] == "testdata":
+        build_test_data(args[1])
+    elif len(args) == 3 and args[0] == "rpc-server":
+        doRpcServer(int(args[1]), int(args[2]))
+    elif len(args) == 2 and args[0] == "rpc-client-python-service":
+        doRpcClientToPythonSvc(int(args[1]))
+    elif len(args) == 2 and args[0] == "rpc-client-go-service":
+        doRpcClientToGoSvc(int(args[1]))
+    else:
+        print("Usage: test.py " + 
+              "[testdata|rpc-server|rpc-client-python-service|rpc-client-go-service] ...")
+    
+if __name__ == "__main__":
+    doMain(sys.argv[1:])

vendor/github.com/ugorji/go/codec/writer.go

@@ -0,0 +1,289 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+package codec
+
+import "io"
+
+// encWriter abstracts writing to a byte array or to an io.Writer.
+type encWriter interface {
+	writeb([]byte)
+	writestr(string)
+	writeqstr(string) // write string wrapped in quotes ie "..."
+	writen1(byte)
+
+	// add convenience functions for writing 2,4
+	writen2(byte, byte)
+	writen4([4]byte)
+	writen8([8]byte)
+
+	end()
+}
+
+// ---------------------------------------------
+
+type bufioEncWriter struct {
+	w io.Writer
+
+	buf []byte
+
+	n int
+
+	b [16]byte // scratch buffer and padding (cache-aligned)
+}
+
+func (z *bufioEncWriter) reset(w io.Writer, bufsize int, blist *bytesFreelist) {
+	z.w = w
+	z.n = 0
+	if bufsize <= 0 {
+		bufsize = defEncByteBufSize
+	}
+	// bufsize must be >= 8, to accomodate writen methods (where n <= 8)
+	if bufsize <= 8 {
+		bufsize = 8
+	}
+	if cap(z.buf) < bufsize {
+		if len(z.buf) > 0 && &z.buf[0] != &z.b[0] {
+			blist.put(z.buf)
+		}
+		if len(z.b) > bufsize {
+			z.buf = z.b[:]
+		} else {
+			z.buf = blist.get(bufsize)
+		}
+	}
+	z.buf = z.buf[:cap(z.buf)]
+}
+
+func (z *bufioEncWriter) flushErr() (err error) {
+	n, err := z.w.Write(z.buf[:z.n])
+	z.n -= n
+	if z.n > 0 {
+		if err == nil {
+			err = io.ErrShortWrite
+		}
+		if n > 0 {
+			copy(z.buf, z.buf[n:z.n+n])
+		}
+	}
+	return err
+}
+
+func (z *bufioEncWriter) flush() {
+	halt.onerror(z.flushErr())
+}
+
+func (z *bufioEncWriter) writeb(s []byte) {
+LOOP:
+	a := len(z.buf) - z.n
+	if len(s) > a {
+		z.n += copy(z.buf[z.n:], s[:a])
+		s = s[a:]
+		z.flush()
+		goto LOOP
+	}
+	z.n += copy(z.buf[z.n:], s)
+}
+
+func (z *bufioEncWriter) writestr(s string) {
+	// z.writeb(bytesView(s)) // inlined below
+LOOP:
+	a := len(z.buf) - z.n
+	if len(s) > a {
+		z.n += copy(z.buf[z.n:], s[:a])
+		s = s[a:]
+		z.flush()
+		goto LOOP
+	}
+	z.n += copy(z.buf[z.n:], s)
+}
+
+func (z *bufioEncWriter) writeqstr(s string) {
+	// z.writen1('"')
+	// z.writestr(s)
+	// z.writen1('"')
+
+	if z.n+len(s)+2 > len(z.buf) {
+		z.flush()
+	}
+	z.buf[z.n] = '"'
+	z.n++
+LOOP:
+	a := len(z.buf) - z.n
+	if len(s)+1 > a {
+		z.n += copy(z.buf[z.n:], s[:a])
+		s = s[a:]
+		z.flush()
+		goto LOOP
+	}
+	z.n += copy(z.buf[z.n:], s)
+	z.buf[z.n] = '"'
+	z.n++
+}
+
+func (z *bufioEncWriter) writen1(b1 byte) {
+	if 1 > len(z.buf)-z.n {
+		z.flush()
+	}
+	z.buf[z.n] = b1
+	z.n++
+}
+func (z *bufioEncWriter) writen2(b1, b2 byte) {
+	if 2 > len(z.buf)-z.n {
+		z.flush()
+	}
+	z.buf[z.n+1] = b2
+	z.buf[z.n] = b1
+	z.n += 2
+}
+func (z *bufioEncWriter) writen4(b [4]byte) {
+	if 4 > len(z.buf)-z.n {
+		z.flush()
+	}
+	copy(z.buf[z.n:], b[:])
+	z.n += 4
+}
+
+func (z *bufioEncWriter) writen8(b [8]byte) {
+	if 8 > len(z.buf)-z.n {
+		z.flush()
+	}
+	copy(z.buf[z.n:], b[:])
+	z.n += 8
+}
+
+func (z *bufioEncWriter) endErr() (err error) {
+	if z.n > 0 {
+		err = z.flushErr()
+	}
+	return
+}
+
+// ---------------------------------------------
+
+// bytesEncAppender implements encWriter and can write to an byte slice.
+type bytesEncAppender struct {
+	b   []byte
+	out *[]byte
+}
+
+func (z *bytesEncAppender) writeb(s []byte) {
+	z.b = append(z.b, s...)
+}
+func (z *bytesEncAppender) writestr(s string) {
+	z.b = append(z.b, s...)
+}
+func (z *bytesEncAppender) writeqstr(s string) {
+	z.b = append(append(append(z.b, '"'), s...), '"')
+	// z.b = append(z.b, '"')
+	// z.b = append(z.b, s...)
+	// z.b = append(z.b, '"')
+}
+func (z *bytesEncAppender) writen1(b1 byte) {
+	z.b = append(z.b, b1)
+}
+func (z *bytesEncAppender) writen2(b1, b2 byte) {
+	z.b = append(z.b, b1, b2)
+}
+func (z *bytesEncAppender) writen4(b [4]byte) {
+	z.b = append(z.b, b[:]...)
+	// z.b = append(z.b, b[0], b[1], b[2], b[3]) // prevents inlining encWr.writen4
+}
+func (z *bytesEncAppender) writen8(b [8]byte) {
+	z.b = append(z.b, b[:]...)
+	// z.b = append(z.b, b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]) // prevents inlining encWr.writen4
+}
+func (z *bytesEncAppender) endErr() error {
+	*(z.out) = z.b
+	return nil
+}
+func (z *bytesEncAppender) reset(in []byte, out *[]byte) {
+	z.b = in[:0]
+	z.out = out
+}
+
+// --------------------------------------------------
+
+type encWr struct {
+	bytes bool // encoding to []byte
+	js    bool // is json encoder?
+	be    bool // is binary encoder?
+
+	c containerState
+
+	calls uint16
+	seq   uint16 // sequencer (e.g. used by binc for symbols, etc)
+	wb    bytesEncAppender
+	wf    *bufioEncWriter
+}
+
+// MARKER: manually inline bytesEncAppender.writenx/writeqstr methods,
+// as calling them causes encWr.writenx/writeqstr methods to not be inlined (cost > 80).
+//
+// i.e. e.g. instead of writing z.wb.writen2(b1, b2), use z.wb.b = append(z.wb.b, b1, b2)
+
+func (z *encWr) writeb(s []byte) {
+	if z.bytes {
+		z.wb.writeb(s)
+	} else {
+		z.wf.writeb(s)
+	}
+}
+func (z *encWr) writeqstr(s string) {
+	if z.bytes {
+		// MARKER: z.wb.writeqstr(s)
+		z.wb.b = append(append(append(z.wb.b, '"'), s...), '"')
+	} else {
+		z.wf.writeqstr(s)
+	}
+}
+func (z *encWr) writestr(s string) {
+	if z.bytes {
+		z.wb.writestr(s)
+	} else {
+		z.wf.writestr(s)
+	}
+}
+func (z *encWr) writen1(b1 byte) {
+	if z.bytes {
+		z.wb.writen1(b1)
+	} else {
+		z.wf.writen1(b1)
+	}
+}
+
+func (z *encWr) writen2(b1, b2 byte) {
+	if z.bytes {
+		// MARKER: z.wb.writen2(b1, b2)
+		z.wb.b = append(z.wb.b, b1, b2)
+	} else {
+		z.wf.writen2(b1, b2)
+	}
+}
+func (z *encWr) writen4(b [4]byte) {
+	if z.bytes {
+		z.wb.writen4(b)
+	} else {
+		z.wf.writen4(b)
+	}
+}
+func (z *encWr) writen8(b [8]byte) {
+	if z.bytes {
+		z.wb.writen8(b)
+	} else {
+		z.wf.writen8(b)
+	}
+}
+
+func (z *encWr) endErr() error {
+	if z.bytes {
+		return z.wb.endErr()
+	}
+	return z.wf.endErr()
+}
+
+func (z *encWr) end() {
+	halt.onerror(z.endErr())
+}
+
+var _ encWriter = (*encWr)(nil)