func (l *LARS) Register404(notFound ...Handler) {
	chain := make(HandlersChain, len(notFound))
	for i, h := range notFound {
		chain[i] = l.wrapHandler(h)
	}
	l.http404 = chain
}
Register404 alows for overriding of the not found handler function.
NOTE: this is run after not finding a route even after redirecting with the trailing slash
package lars
import (
	"fmt"
	"net/http"
	"reflect"
	"strings"
	"sync"
	"github.com/go-playground/form"
)
const (
	CONNECT = http.MethodConnect
	DELETE = http.MethodDelete
	GET = http.MethodGet
	HEAD = http.MethodHead
	OPTIONS = http.MethodOptions
	PATCH = http.MethodPatch
	POST = http.MethodPost
	PUT = http.MethodPut
	TRACE = http.MethodTrace
	ApplicationJSON                  = "application/json"
	ApplicationJSONCharsetUTF8       = ApplicationJSON + "; " + CharsetUTF8
	ApplicationJavaScript            = "application/javascript"
	ApplicationJavaScriptCharsetUTF8 = ApplicationJavaScript + "; " + CharsetUTF8
	ApplicationXML                   = "application/xml"
	ApplicationXMLCharsetUTF8        = ApplicationXML + "; " + CharsetUTF8
	ApplicationForm                  = "application/x-www-form-urlencoded"
	ApplicationProtobuf              = "application/protobuf"
	ApplicationMsgpack               = "application/msgpack"
	TextHTML                         = "text/html"
	TextHTMLCharsetUTF8              = TextHTML + "; " + CharsetUTF8
	TextPlain                        = "text/plain"
	TextPlainCharsetUTF8             = TextPlain + "; " + CharsetUTF8
	MultipartForm                    = "multipart/form-data"
	OctetStream                      = "application/octet-stream"
	CharsetUTF8 = "charset=utf-8"
	AcceptedLanguage   = "Accept-Language"
	AcceptEncoding     = "Accept-Encoding"
	Authorization      = "Authorization"
	ContentDisposition = "Content-Disposition"
	ContentEncoding    = "Content-Encoding"
	ContentLength      = "Content-Length"
	ContentType        = "Content-Type"
	Location           = "Location"
	Upgrade            = "Upgrade"
	Vary               = "Vary"
	WWWAuthenticate    = "WWW-Authenticate"
	XForwardedFor      = "X-Forwarded-For"
	XRealIP            = "X-Real-Ip"
	Allow              = "Allow"
	Origin             = "Origin"
	Gzip = "gzip"
	WildcardParam = "*wildcard"
	basePath = "/"
	blank    = ""
	slashByte = '/'
	paramByte = ':'
	wildByte  = '*'
)
type Handler interface{}
type HandlerFunc func(Context)
type HandlersChain []HandlerFunc
type ContextFunc func(l *LARS) Context
type CustomHandlerFunc func(Context, Handler)
type customHandlers map[reflect.Type]CustomHandlerFunc
type LARS struct {
	routeGroup
	trees map[string]*node
	contextFunc ContextFunc
	pool sync.Pool
	http404 HandlersChain  
	http405 HandlersChain  
	automaticOPTIONS HandlersChain
	notFound         HandlersChain
	customHandlersFuncs customHandlers
	mostParams uint8
	redirectTrailingSlash bool
	handleMethodNotAllowed bool
	automaticallyHandleOPTIONS bool
}
type RouteMap struct {
	Depth   int    `json:"depth"`
	Path    string `json:"path"`
	Method  string `json:"method"`
	Handler string `json:"handler"`
}
var (
	default404Handler = func(c Context) {
		http.Error(c.Response(), http.StatusText(http.StatusNotFound), http.StatusNotFound)
	}
	methodNotAllowedHandler = func(c Context) {
		c.Response().WriteHeader(http.StatusMethodNotAllowed)
	}
	automaticOPTIONSHandler = func(c Context) {
		c.Response().WriteHeader(http.StatusOK)
	}
	formDecoder     *form.Decoder
	formDecoderInit sync.Once
)
func New() *LARS {
	l := &LARS{
		routeGroup: routeGroup{
			middleware: make(HandlersChain, 0),
		},
		trees: make(map[string]*node),
		contextFunc: func(l *LARS) Context {
			return NewContext(l)
		},
		mostParams:                 0,
		http404:                    []HandlerFunc{default404Handler},
		http405:                    []HandlerFunc{methodNotAllowedHandler},
		redirectTrailingSlash:      true,
		handleMethodNotAllowed:     false,
		automaticallyHandleOPTIONS: false,
	}
	l.routeGroup.lars = l
	l.pool.New = func() interface{} {
		c := l.contextFunc(l)
		b := c.BaseContext()
		b.parent = c
		return b
	}
	return l
}
func initFormDecoder() {
	formDecoderInit.Do(func() {
		formDecoder = form.NewDecoder()
	})
}
func (l *LARS) BuiltInFormDecoder() *form.Decoder {
	initFormDecoder()
	return formDecoder
}
func (l *LARS) RegisterCustomHandler(customType interface{}, fn CustomHandlerFunc) {
	if l.customHandlersFuncs == nil {
		l.customHandlersFuncs = make(customHandlers)
	}
	t := reflect.TypeOf(customType)
	if _, ok := l.customHandlersFuncs[t]; ok {
		panic(fmt.Sprint("Custom Type + CustomHandlerFunc already declared: ", t))
	}
	l.customHandlersFuncs[t] = fn
}
func (l *LARS) RegisterContext(fn ContextFunc) {
	l.contextFunc = fn
}