func (resp *Response) ReleaseBody(size int) {
	resp.bodyRaw = nil
	if cap(resp.body.B) > size {
		resp.closeBodyStream()
		resp.body = nil
	}
}
ReleaseBody retires the response body if it is greater than "size" bytes.

This permits GC to reclaim the large buffer.  If used, must be before
ReleaseResponse.

Use this method only if you really understand how it works.
The majority of workloads don't need this method.
package fasthttp
import (
	"bufio"
	"bytes"
	"encoding/base64"
	"errors"
	"fmt"
	"io"
	"mime/multipart"
	"net"
	"os"
	"sync"
	"github.com/valyala/bytebufferpool"
)
type Request struct {
	noCopy noCopy
	Header RequestHeader
	uri      URI
	postArgs Args
	bodyStream io.Reader
	w          requestBodyWriter
	body       *bytebufferpool.ByteBuffer
	multipartForm         *multipart.Form
	multipartFormBoundary string
	parsedURI      bool
	parsedPostArgs bool
	keepBodyBuffer bool
	isTLS bool
	schemaUpdate bool
}
type Response struct {
	noCopy noCopy
	Header ResponseHeader
	ImmediateHeaderFlush bool
	bodyStream io.Reader
	w          responseBodyWriter
	body       *bytebufferpool.ByteBuffer
	bodyRaw    []byte
	SkipBody bool
	keepBodyBuffer bool
	raddr net.Addr
	laddr net.Addr
}
func (req *Request) SetHost(host string) {
	req.URI().SetHost(host)
}
func (req *Request) SetHostBytes(host []byte) {
	req.URI().SetHostBytes(host)
}
func (req *Request) Host() []byte {
	return req.URI().Host()
}
func (req *Request) SetRequestURI(requestURI string) {
	req.Header.SetRequestURI(requestURI)
	req.parsedURI = false
}
func (req *Request) SetRequestURIBytes(requestURI []byte) {
	req.Header.SetRequestURIBytes(requestURI)
	req.parsedURI = false
}
func (req *Request) RequestURI() []byte {
	if req.parsedURI {
		requestURI := req.uri.RequestURI()
		req.SetRequestURIBytes(requestURI)
	}
	return req.Header.RequestURI()
}
func (resp *Response) StatusCode() int {
	return resp.Header.StatusCode()
}
func (resp *Response) SetStatusCode(statusCode int) {
	resp.Header.SetStatusCode(statusCode)
}
func (resp *Response) ConnectionClose() bool {
	return resp.Header.ConnectionClose()
}
func (resp *Response) SetConnectionClose() {
	resp.Header.SetConnectionClose()
}
func (req *Request) ConnectionClose() bool {
	return req.Header.ConnectionClose()
}
func (req *Request) SetConnectionClose() {
	req.Header.SetConnectionClose()
}
func (resp *Response) SendFile(path string) error {
	f, err := os.Open(path)
	if err != nil {
		return err
	}
	fileInfo, err := f.Stat()
	if err != nil {
		f.Close()
		return err
	}
	size64 := fileInfo.Size()
	size := int(size64)
	if int64(size) != size64 {
		size = -1
	}
	resp.Header.SetLastModified(fileInfo.ModTime())
	resp.SetBodyStream(f, size)
	return nil
}
func (req *Request) SetBodyStream(bodyStream io.Reader, bodySize int) {
	req.ResetBody()
	req.bodyStream = bodyStream
	req.Header.SetContentLength(bodySize)
}
func (resp *Response) SetBodyStream(bodyStream io.Reader, bodySize int) {
	resp.ResetBody()
	resp.bodyStream = bodyStream
	resp.Header.SetContentLength(bodySize)
}
func (req *Request) IsBodyStream() bool {
	return req.bodyStream != nil
}
func (resp *Response) IsBodyStream() bool {
	return resp.bodyStream != nil
}
func (req *Request) SetBodyStreamWriter(sw StreamWriter) {
	sr := NewStreamReader(sw)
	req.SetBodyStream(sr, -1)
}
func (resp *Response) SetBodyStreamWriter(sw StreamWriter) {
	sr := NewStreamReader(sw)
	resp.SetBodyStream(sr, -1)
}
func (resp *Response) BodyWriter() io.Writer {
	resp.w.r = resp
	return &resp.w
}
func (req *Request) BodyWriter() io.Writer {
	req.w.r = req
	return &req.w
}
type responseBodyWriter struct {
	r *Response
}
func (w *responseBodyWriter) Write(p []byte) (int, error) {
	w.r.AppendBody(p)
	return len(p), nil
}
type requestBodyWriter struct {
	r *Request
}
func (w *requestBodyWriter) Write(p []byte) (int, error) {
	w.r.AppendBody(p)
	return len(p), nil
}
func (resp *Response) parseNetConn(conn net.Conn) {
	resp.raddr = conn.RemoteAddr()
	resp.laddr = conn.LocalAddr()
}
func (resp *Response) RemoteAddr() net.Addr {
	return resp.raddr
}
func (resp *Response) LocalAddr() net.Addr {
	return resp.laddr
}
func (resp *Response) Body() []byte {
	if resp.bodyStream != nil {
		bodyBuf := resp.bodyBuffer()
		bodyBuf.Reset()
		_, err := copyZeroAlloc(bodyBuf, resp.bodyStream)
		resp.closeBodyStream()
		if err != nil {
			bodyBuf.SetString(err.Error())
		}
	}
	return resp.bodyBytes()
}
func (resp *Response) bodyBytes() []byte {
	if resp.bodyRaw != nil {
		return resp.bodyRaw
	}
	if resp.body == nil {
		return nil
	}
	return resp.body.B
}
func (req *Request) bodyBytes() []byte {
	if req.body == nil {
		return nil
	}
	return req.body.B
}
func (resp *Response) bodyBuffer() *bytebufferpool.ByteBuffer {
	if resp.body == nil {
		resp.body = responseBodyPool.Get()
	}
	resp.bodyRaw = nil
	return resp.body
}
func (req *Request) bodyBuffer() *bytebufferpool.ByteBuffer {
	if req.body == nil {
		req.body = requestBodyPool.Get()
	}
	return req.body
}
var (
	responseBodyPool bytebufferpool.Pool
	requestBodyPool  bytebufferpool.Pool
)
func (req *Request) BodyGunzip() ([]byte, error) {
	return gunzipData(req.Body())
}
func (resp *Response) BodyGunzip() ([]byte, error) {
	return gunzipData(resp.Body())
}
func gunzipData(p []byte) ([]byte, error) {
	var bb bytebufferpool.ByteBuffer
	_, err := WriteGunzip(&bb, p)
	if err != nil {
		return nil, err
	}
	return bb.B, nil
}
func (req *Request) BodyInflate() ([]byte, error) {
	return inflateData(req.Body())
}
func (resp *Response) BodyInflate() ([]byte, error) {
	return inflateData(resp.Body())
}
func inflateData(p []byte) ([]byte, error) {
	var bb bytebufferpool.ByteBuffer
	_, err := WriteInflate(&bb, p)
	if err != nil {
		return nil, err
	}
	return bb.B, nil
}
func (req *Request) BodyWriteTo(w io.Writer) error {
	if req.bodyStream != nil {
		_, err := copyZeroAlloc(w, req.bodyStream)
		req.closeBodyStream()
		return err
	}
	if req.onlyMultipartForm() {
		return WriteMultipartForm(w, req.multipartForm, req.multipartFormBoundary)
	}
	_, err := w.Write(req.bodyBytes())
	return err
}
func (resp *Response) BodyWriteTo(w io.Writer) error {
	if resp.bodyStream != nil {
		_, err := copyZeroAlloc(w, resp.bodyStream)
		resp.closeBodyStream()
		return err
	}
	_, err := w.Write(resp.bodyBytes())
	return err
}
func (resp *Response) AppendBody(p []byte) {
	resp.AppendBodyString(b2s(p))
}
func (resp *Response) AppendBodyString(s string) {
	resp.closeBodyStream()
	resp.bodyBuffer().WriteString(s)
}
func (resp *Response) SetBody(body []byte) {
	resp.SetBodyString(b2s(body))
}
func (resp *Response) SetBodyString(body string) {
	resp.closeBodyStream()
	bodyBuf := resp.bodyBuffer()
	bodyBuf.Reset()
	bodyBuf.WriteString(body)
}
func (resp *Response) ResetBody() {
	resp.bodyRaw = nil
	resp.closeBodyStream()
	if resp.body != nil {
		if resp.keepBodyBuffer {
			resp.body.Reset()
		} else {
			responseBodyPool.Put(resp.body)
			resp.body = nil
		}
	}
}
func (resp *Response) SetBodyRaw(body []byte) {
	resp.ResetBody()
	resp.bodyRaw = body
}