func (i IntOverflow) Error() string {
	str := fmt.Sprintf("msgp: %d overflows int%d", i.Value, i.FailedBitsize)
	if i.ctx != "" {
		str += " at " + i.ctx
	}
	return str
}
Error implements the error interface
package msgp
import (
	"fmt"
	"reflect"
	"strings"
)
const resumableDefault = false
var (
	ErrShortBytes error = errShort{}
	fatal error = errFatal{}
)
type Error interface {
	error
	Resumable() bool
}
type contextError interface {
	Error
	withContext(ctx string) error
}
func Cause(e error) error {
	out := e
	if e, ok := e.(errWrapped); ok && e.cause != nil {
		out = e.cause
	}
	return out
}
func Resumable(e error) bool {
	if e, ok := e.(Error); ok {
		return e.Resumable()
	}
	return resumableDefault
}
func WrapError(err error, ctx ...interface{}) error {
	switch e := err.(type) {
	case errShort:
		return e
	case contextError:
		return e.withContext(ctxString(ctx))
	default:
		return errWrapped{cause: err, ctx: ctxString(ctx)}
	}
}
func ctxString(ctx []interface{}) string {
	out := ""
	for idx, cv := range ctx {
		if idx > 0 {
			out += "/"
		}
		out += fmt.Sprintf("%v", cv)
	}
	return out
}
func addCtx(ctx, add string) string {
	if ctx != "" {
		return add + "/" + ctx
	} else {
		return add
	}
}
type errWrapped struct {
	cause error
	ctx   string
}
func (e errWrapped) Error() string {
	if e.ctx != "" {
		return strings.Join([]string{e.cause.Error(), "at", e.ctx}, " ")
	} else {
		return e.cause.Error()
	}
}
func (e errWrapped) Resumable() bool {
	if e, ok := e.cause.(Error); ok {
		return e.Resumable()
	}
	return resumableDefault
}
func (e errWrapped) Unwrap() error { return e.cause }
type errShort struct{}
func (e errShort) Error() string   { return "msgp: too few bytes left to read object" }
func (e errShort) Resumable() bool { return false }
type errFatal struct {
	ctx string
}
func (f errFatal) Error() string {
	out := "msgp: fatal decoding error (unreachable code)"
	if f.ctx != "" {
		out += " at " + f.ctx
	}
	return out
}
func (f errFatal) Resumable() bool { return false }
func (f errFatal) withContext(ctx string) error { f.ctx = addCtx(f.ctx, ctx); return f }
type ArrayError struct {
	Wanted uint32
	Got    uint32
	ctx    string
}
func (a ArrayError) Error() string {
	out := fmt.Sprintf("msgp: wanted array of size %d; got %d", a.Wanted, a.Got)
	if a.ctx != "" {
		out += " at " + a.ctx
	}
	return out
}
func (a ArrayError) Resumable() bool { return true }
func (a ArrayError) withContext(ctx string) error { a.ctx = addCtx(a.ctx, ctx); return a }
type IntOverflow struct {
	Value         int64  
	FailedBitsize int    
	ctx           string
}