encode_string_le.go - master - uzer_007/gobase64

encode_string_le.go
489 строк20 KB
uzer_007
release: v1.1.0
12 авг 2026, 01:34
12 авг 2026, 01:34b80d01d
//go:build !race && !purego && (386 || amd64 || arm64 || wasm)

package base64

import (
	"math/bits"
	"unsafe"
)

func encodeStringStdPadded1Fast(t *encodingTables, src []byte) string {
	p := new(uint32)
	*p = t.enc1[src[0]] | uint32('=')<<16 | uint32('=')<<24
	return unsafe.String((*byte)(unsafe.Pointer(p)), 4)
}

func encodeStringStdPadded2Fast(t *encodingTables, src []byte) string {
	p := new(uint32)
	b0, b1 := src[0], src[1]
	*p = uint32(t.encQuad[int(b0)<<4|int(b1>>4)]) | uint32(t.encode[(b1&0x0f)<<2])<<16 | uint32('=')<<24
	return unsafe.String((*byte)(unsafe.Pointer(p)), 4)
}

func encodeStringStdPadded3Fast(t *encodingTables, src []byte) string {
	val := uint32(src[0])<<16 | uint32(src[1])<<8 | uint32(src[2])
	p := new(uint32)
	*p = t.encQuad[val>>12] | t.encQuad[val&0x0fff]<<16
	return unsafe.String((*byte)(unsafe.Pointer(p)), 4)
}

func encodeStringStdPadded4Fast(t *encodingTables, src []byte) string {
	buf := new([8]byte)
	q0 := encodeStringFullQuantum(t, src[0], src[1], src[2])
	b0 := src[3]
	q1 := uint32(t.encQuad[int(b0>>2)<<6|int((b0&0x03)<<4)]) | uint32('=')<<16 | uint32('=')<<24
	*(*uint64)(unsafe.Pointer(&buf[0])) = uint64(q0) | uint64(q1)<<32
	return bytesToString(buf[:])
}

func encodeStringStdPadded5Fast(t *encodingTables, src []byte) string {
	buf := new([8]byte)
	q0 := encodeStringFullQuantum(t, src[0], src[1], src[2])
	b0, b1 := src[3], src[4]
	q1 := uint32(t.encQuad[int(b0)<<4|int(b1>>4)]) | uint32(t.encode[(b1&0x0f)<<2])<<16 | uint32('=')<<24
	*(*uint64)(unsafe.Pointer(&buf[0])) = uint64(q0) | uint64(q1)<<32
	return bytesToString(buf[:])
}

func encodeStringStdPadded6Fast(t *encodingTables, src []byte) string {
	buf := new([8]byte)
	q0 := encodeStringFullQuantum(t, src[0], src[1], src[2])
	q1 := encodeStringFullQuantum(t, src[3], src[4], src[5])
	*(*uint64)(unsafe.Pointer(&buf[0])) = uint64(q0) | uint64(q1)<<32
	return bytesToString(buf[:])
}

func encodeStringStdPadded7Fast(t *encodingTables, src []byte) string {
	buf := new([12]byte)
	op := unsafe.Pointer(&buf[0])
	encodeStringManualQuantum(t, op, src[0], src[1], src[2])
	encodeStringManualQuantum(t, unsafe.Add(op, 4), src[3], src[4], src[5])
	b0 := src[6]
	*(*uint32)(unsafe.Add(op, 8)) = uint32(t.encQuad[int(b0>>2)<<6|int((b0&0x03)<<4)]) | uint32('=')<<16 | uint32('=')<<24
	return bytesToString(buf[:])
}

func encodeStringStdPadded8Fast(t *encodingTables, src []byte) string {
	buf := new([12]byte)
	op := unsafe.Pointer(&buf[0])
	encodeStringManualQuantum(t, op, src[0], src[1], src[2])
	encodeStringManualQuantum(t, unsafe.Add(op, 4), src[3], src[4], src[5])
	b0, b1 := src[6], src[7]
	*(*uint32)(unsafe.Add(op, 8)) = uint32(t.encQuad[int(b0)<<4|int(b1>>4)]) | uint32(t.encode[(b1&0x0f)<<2])<<16 | uint32('=')<<24
	return bytesToString(buf[:])
}

func encodeStringStdPadded9Fast(t *encodingTables, src []byte) string {
	buf := new([12]byte)
	ip := unsafe.Pointer(unsafe.SliceData(src))
	op := unsafe.Pointer(&buf[0])
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 0), unsafe.Add(ip, 0))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 4), unsafe.Add(ip, 3))
	encodeStringUnsafeTail3(t, unsafe.Add(op, 8), unsafe.Add(ip, 6))
	return bytesToString(buf[:])
}

func encodeStringStdPadded10Fast(t *encodingTables, src []byte) string {
	buf := new([16]byte)
	ip := unsafe.Pointer(unsafe.SliceData(src))
	op := unsafe.Pointer(&buf[0])
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 0), unsafe.Add(ip, 0))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 4), unsafe.Add(ip, 3))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 8), unsafe.Add(ip, 6))
	b0 := *(*byte)(unsafe.Add(ip, 9))
	*(*uint32)(unsafe.Add(op, 12)) = uint32(t.encQuad[int(b0>>2)<<6|int((b0&0x03)<<4)]) | uint32('=')<<16 | uint32('=')<<24
	return bytesToString(buf[:])
}

func encodeStringStdPadded11Fast(t *encodingTables, src []byte) string {
	buf := new([16]byte)
	ip := unsafe.Pointer(unsafe.SliceData(src))
	op := unsafe.Pointer(&buf[0])
	u := bits.ReverseBytes32(*(*uint32)(unsafe.Add(ip, 0)))
	*(*uint32)(unsafe.Add(op, 0)) = t.encQuad[u>>20] | t.encQuad[(u>>8)&0x0fff]<<16
	u = bits.ReverseBytes32(*(*uint32)(unsafe.Add(ip, 3)))
	*(*uint32)(unsafe.Add(op, 4)) = t.encQuad[u>>20] | t.encQuad[(u>>8)&0x0fff]<<16
	u = bits.ReverseBytes32(*(*uint32)(unsafe.Add(ip, 6)))
	*(*uint32)(unsafe.Add(op, 8)) = t.encQuad[u>>20] | t.encQuad[(u>>8)&0x0fff]<<16
	b0 := *(*byte)(unsafe.Add(ip, 9))
	b1 := *(*byte)(unsafe.Add(ip, 10))
	*(*uint32)(unsafe.Add(op, 12)) = uint32(t.encQuad[int(b0)<<4|int(b1>>4)]) | uint32(t.encode[(b1&0x0f)<<2])<<16 | uint32('=')<<24
	return bytesToString(buf[:])
}

func encodeStringStdPadded12Fast(t *encodingTables, src []byte) string {
	buf := new([16]byte)
	ip := unsafe.Pointer(unsafe.SliceData(src))
	op := unsafe.Pointer(&buf[0])
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 0), unsafe.Add(ip, 0))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 4), unsafe.Add(ip, 3))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 8), unsafe.Add(ip, 6))
	encodeStringUnsafeTail3(t, unsafe.Add(op, 12), unsafe.Add(ip, 9))
	return bytesToString(buf[:])
}

func encodeStringStdPadded13Fast(t *encodingTables, src []byte) string {
	buf := new([20]byte)
	ip := unsafe.Pointer(unsafe.SliceData(src))
	op := unsafe.Pointer(&buf[0])
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 0), unsafe.Add(ip, 0))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 4), unsafe.Add(ip, 3))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 8), unsafe.Add(ip, 6))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 12), unsafe.Add(ip, 9))
	b0 := *(*byte)(unsafe.Add(ip, 12))
	*(*uint32)(unsafe.Add(op, 16)) = uint32(t.encQuad[int(b0>>2)<<6|int((b0&0x03)<<4)]) | uint32('=')<<16 | uint32('=')<<24
	return bytesToString(buf[:])
}

func encodeStringStdPadded14Fast(t *encodingTables, src []byte) string {
	buf := new([20]byte)
	ip := unsafe.Pointer(unsafe.SliceData(src))
	op := unsafe.Pointer(&buf[0])
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 0), unsafe.Add(ip, 0))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 4), unsafe.Add(ip, 3))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 8), unsafe.Add(ip, 6))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 12), unsafe.Add(ip, 9))
	b0 := *(*byte)(unsafe.Add(ip, 12))
	b1 := *(*byte)(unsafe.Add(ip, 13))
	*(*uint32)(unsafe.Add(op, 16)) = uint32(t.encQuad[int(b0)<<4|int(b1>>4)]) | uint32(t.encode[(b1&0x0f)<<2])<<16 | uint32('=')<<24
	return bytesToString(buf[:])
}

func encodeStringStdPadded15Fast(t *encodingTables, src []byte) string {
	buf := new([20]byte)
	ip := unsafe.Pointer(unsafe.SliceData(src))
	op := unsafe.Pointer(&buf[0])
	u := bits.ReverseBytes32(*(*uint32)(unsafe.Add(ip, 0)))
	*(*uint32)(unsafe.Add(op, 0)) = t.encQuad[u>>20] | t.encQuad[(u>>8)&0x0fff]<<16
	u = bits.ReverseBytes32(*(*uint32)(unsafe.Add(ip, 3)))
	*(*uint32)(unsafe.Add(op, 4)) = t.encQuad[u>>20] | t.encQuad[(u>>8)&0x0fff]<<16
	u = bits.ReverseBytes32(*(*uint32)(unsafe.Add(ip, 6)))
	*(*uint32)(unsafe.Add(op, 8)) = t.encQuad[u>>20] | t.encQuad[(u>>8)&0x0fff]<<16
	u = bits.ReverseBytes32(*(*uint32)(unsafe.Add(ip, 9)))
	*(*uint32)(unsafe.Add(op, 12)) = t.encQuad[u>>20] | t.encQuad[(u>>8)&0x0fff]<<16
	b0 := *(*byte)(unsafe.Add(ip, 12))
	b1 := *(*byte)(unsafe.Add(ip, 13))
	b2 := *(*byte)(unsafe.Add(ip, 14))
	val := uint32(b0)<<16 | uint32(b1)<<8 | uint32(b2)
	*(*uint32)(unsafe.Add(op, 16)) = t.encQuad[val>>12] | t.encQuad[val&0x0fff]<<16
	return bytesToString(buf[:])
}

func encodeStringStdPadded16Fast(t *encodingTables, src []byte) string {
	buf := new([24]byte)
	ip := unsafe.Pointer(unsafe.SliceData(src))
	op := unsafe.Pointer(&buf[0])
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 0), unsafe.Add(ip, 0))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 4), unsafe.Add(ip, 3))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 8), unsafe.Add(ip, 6))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 12), unsafe.Add(ip, 9))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 16), unsafe.Add(ip, 12))
	b0 := *(*byte)(unsafe.Add(ip, 15))
	*(*uint32)(unsafe.Add(op, 20)) = uint32(t.encQuad[int(b0>>2)<<6|int((b0&0x03)<<4)]) | uint32('=')<<16 | uint32('=')<<24
	return bytesToString(buf[:])
}

func encodeStringStdPadded24Fast(t *encodingTables, src []byte) string {
	buf := new([32]byte)
	ip := unsafe.Pointer(unsafe.SliceData(src))
	op := unsafe.Pointer(&buf[0])
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 0), unsafe.Add(ip, 0))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 4), unsafe.Add(ip, 3))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 8), unsafe.Add(ip, 6))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 12), unsafe.Add(ip, 9))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 16), unsafe.Add(ip, 12))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 20), unsafe.Add(ip, 15))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 24), unsafe.Add(ip, 18))
	encodeStringManualQuantum(t, unsafe.Add(op, 28), src[21], src[22], src[23])
	return bytesToString(buf[:])
}

func encodeStringStdPadded32Fast(t *encodingTables, src []byte) string {
	buf := new([44]byte)
	encodeStdPadded32(t, buf[:], src)
	return bytesToString(buf[:])
}

func encodeStringStdPadded48Fast(t *encodingTables, src []byte) string {
	buf := new([64]byte)
	ip := unsafe.Pointer(unsafe.SliceData(src))
	op := unsafe.Pointer(&buf[0])
	encodeStringUnsafePair(t, unsafe.Add(op, 0), unsafe.Add(ip, 0))
	encodeStringUnsafePair(t, unsafe.Add(op, 8), unsafe.Add(ip, 6))
	encodeStringUnsafePair(t, unsafe.Add(op, 16), unsafe.Add(ip, 12))
	encodeStringUnsafePair(t, unsafe.Add(op, 24), unsafe.Add(ip, 18))
	encodeStringUnsafePair(t, unsafe.Add(op, 32), unsafe.Add(ip, 24))
	encodeStringUnsafePair(t, unsafe.Add(op, 40), unsafe.Add(ip, 30))
	encodeStringUnsafePair(t, unsafe.Add(op, 48), unsafe.Add(ip, 36))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 56), unsafe.Add(ip, 42))
	encodeStringManualQuantum(t, unsafe.Add(op, 60), src[45], src[46], src[47])
	return bytesToString(buf[:])
}

func encodeStringStdPadded64Fast(t *encodingTables, src []byte) string {
	buf := makeNoZero(88)
	ip := unsafe.Pointer(unsafe.SliceData(src))
	op := unsafe.Pointer(unsafe.SliceData(buf))
	u0x := bits.ReverseBytes32(*(*uint32)(ip))
	u1x := bits.ReverseBytes32(*(*uint32)(unsafe.Add(ip, 3)))
	for i := 0; i < 4; i++ {
		u0, u1 := u0x, u1x
		u0x = bits.ReverseBytes32(*(*uint32)(unsafe.Add(ip, 6)))
		u1x = bits.ReverseBytes32(*(*uint32)(unsafe.Add(ip, 9)))
		q0 := t.encQuad[u0>>20] | t.encQuad[(u0>>8)&0x0fff]<<16
		q1 := t.encQuad[u1>>20] | t.encQuad[(u1>>8)&0x0fff]<<16
		*(*uint64)(op) = uint64(q0) | uint64(q1)<<32

		u0, u1 = u0x, u1x
		u0x = bits.ReverseBytes32(*(*uint32)(unsafe.Add(ip, 12)))
		u1x = bits.ReverseBytes32(*(*uint32)(unsafe.Add(ip, 15)))
		q0 = t.encQuad[u0>>20] | t.encQuad[(u0>>8)&0x0fff]<<16
		q1 = t.encQuad[u1>>20] | t.encQuad[(u1>>8)&0x0fff]<<16
		*(*uint64)(unsafe.Add(op, 8)) = uint64(q0) | uint64(q1)<<32

		ip = unsafe.Add(ip, 12)
		op = unsafe.Add(op, 16)
	}
	q0 := t.encQuad[u0x>>20] | t.encQuad[(u0x>>8)&0x0fff]<<16
	q1 := t.encQuad[u1x>>20] | t.encQuad[(u1x>>8)&0x0fff]<<16
	*(*uint64)(op) = uint64(q0) | uint64(q1)<<32
	u := bits.ReverseBytes32(*(*uint32)(unsafe.Add(ip, 6)))
	q0 = t.encQuad[u>>20] | t.encQuad[(u>>8)&0x0fff]<<16
	u = bits.ReverseBytes32(*(*uint32)(unsafe.Add(ip, 9)))
	q1 = t.encQuad[u>>20] | t.encQuad[(u>>8)&0x0fff]<<16
	*(*uint64)(unsafe.Add(op, 8)) = uint64(q0) | uint64(q1)<<32
	u = bits.ReverseBytes32(*(*uint32)(unsafe.Add(ip, 12)))
	q0 = t.encQuad[u>>20] | t.encQuad[(u>>8)&0x0fff]<<16
	*(*uint32)(unsafe.Add(op, 16)) = q0
	b0 := *(*byte)(unsafe.Add(ip, 15))
	*(*uint32)(unsafe.Add(op, 20)) = uint32(t.encQuad[int(b0>>2)<<6|int((b0&0x03)<<4)]) | uint32('=')<<16 | uint32('=')<<24
	return bytesToString(buf)
}

func encodeStringStdPadded96Fast(t *encodingTables, src []byte) string {
	buf := make([]byte, 128)
	ip := unsafe.Pointer(unsafe.SliceData(src))
	op := unsafe.Pointer(unsafe.SliceData(buf))
	u0x := bits.ReverseBytes32(*(*uint32)(ip))
	u1x := bits.ReverseBytes32(*(*uint32)(unsafe.Add(ip, 3)))
	for i := 0; i < 7; i++ {
		u0, u1 := u0x, u1x
		u0x = bits.ReverseBytes32(*(*uint32)(unsafe.Add(ip, 6)))
		u1x = bits.ReverseBytes32(*(*uint32)(unsafe.Add(ip, 9)))
		q0 := t.encQuad[u0>>20] | t.encQuad[(u0>>8)&0x0fff]<<16
		q1 := t.encQuad[u1>>20] | t.encQuad[(u1>>8)&0x0fff]<<16
		*(*uint64)(op) = uint64(q0) | uint64(q1)<<32

		u0, u1 = u0x, u1x
		u0x = bits.ReverseBytes32(*(*uint32)(unsafe.Add(ip, 12)))
		u1x = bits.ReverseBytes32(*(*uint32)(unsafe.Add(ip, 15)))
		q0 = t.encQuad[u0>>20] | t.encQuad[(u0>>8)&0x0fff]<<16
		q1 = t.encQuad[u1>>20] | t.encQuad[(u1>>8)&0x0fff]<<16
		*(*uint64)(unsafe.Add(op, 8)) = uint64(q0) | uint64(q1)<<32

		ip = unsafe.Add(ip, 12)
		op = unsafe.Add(op, 16)
	}
	q0 := t.encQuad[u0x>>20] | t.encQuad[(u0x>>8)&0x0fff]<<16
	q1 := t.encQuad[u1x>>20] | t.encQuad[(u1x>>8)&0x0fff]<<16
	*(*uint64)(op) = uint64(q0) | uint64(q1)<<32
	u := bits.ReverseBytes32(*(*uint32)(unsafe.Add(ip, 6)))
	q0 = t.encQuad[u>>20] | t.encQuad[(u>>8)&0x0fff]<<16
	val := uint32(src[93])<<16 | uint32(src[94])<<8 | uint32(src[95])
	q1 = t.encQuad[val>>12] | t.encQuad[val&0x0fff]<<16
	*(*uint64)(unsafe.Add(op, 8)) = uint64(q0) | uint64(q1)<<32
	return bytesToString(buf)
}

func encodeStringUnsafePair(t *encodingTables, op, ip unsafe.Pointer) {
	u := bits.ReverseBytes32(*(*uint32)(ip))
	q0 := t.encQuad[u>>20] | t.encQuad[(u>>8)&0x0fff]<<16
	u = bits.ReverseBytes32(*(*uint32)(unsafe.Add(ip, 3)))
	q1 := t.encQuad[u>>20] | t.encQuad[(u>>8)&0x0fff]<<16
	*(*uint64)(op) = uint64(q0) | uint64(q1)<<32
}

func encodeStringUnsafeQuantum(t *encodingTables, op, ip unsafe.Pointer) {
	u := bits.ReverseBytes32(*(*uint32)(ip))
	*(*uint32)(op) = t.encQuad[u>>20] | t.encQuad[(u>>8)&0x0fff]<<16
}

func encodeStringManualQuantum(t *encodingTables, op unsafe.Pointer, b0, b1, b2 byte) {
	val := uint32(b0)<<16 | uint32(b1)<<8 | uint32(b2)
	*(*uint32)(op) = t.encQuad[val>>12] | t.encQuad[val&0x0fff]<<16
}

func encodeStringFullQuantum(t *encodingTables, b0, b1, b2 byte) uint32 {
	val := uint32(b0)<<16 | uint32(b1)<<8 | uint32(b2)
	return t.encQuad[val>>12] | t.encQuad[val&0x0fff]<<16
}

func encodeStringUnsafeTail3(t *encodingTables, op, ip unsafe.Pointer) {
	b0 := *(*byte)(ip)
	b1 := *(*byte)(unsafe.Add(ip, 1))
	b2 := *(*byte)(unsafe.Add(ip, 2))
	val := uint32(b0)<<16 | uint32(b1)<<8 | uint32(b2)
	*(*uint32)(op) = t.encQuad[val>>12] | t.encQuad[val&0x0fff]<<16
}

func encodeBytesStdPadded1Fast(t *encodingTables, src []byte) []byte {
	buf := new([4]byte)
	b0 := src[0]
	quad := t.encQuad[int(b0>>2)<<6|int((b0&0x03)<<4)]
	buf[0] = byte(quad)
	buf[1] = byte(quad >> 8)
	buf[2] = '='
	buf[3] = '='
	return buf[:]
}

func encodeBytesStdPadded2Fast(t *encodingTables, src []byte) []byte {
	buf := new([4]byte)
	b0, b1 := src[0], src[1]
	*(*uint32)(unsafe.Pointer(&buf[0])) = uint32(t.encQuad[int(b0)<<4|int(b1>>4)]) | uint32(t.encode[(b1&0x0f)<<2])<<16 | uint32('=')<<24
	return buf[:]
}

func encodeBytesStdPadded3Fast(t *encodingTables, src []byte) []byte {
	buf := new([4]byte)
	val := uint32(src[0])<<16 | uint32(src[1])<<8 | uint32(src[2])
	putUint32LE(buf[:], t.encQuad[val>>12]|t.encQuad[val&0x0fff]<<16)
	return buf[:]
}

func encodeBytesStdPadded4Fast(t *encodingTables, src []byte) []byte {
	buf := make([]byte, 8)
	ip := unsafe.Pointer(unsafe.SliceData(src))
	op := unsafe.Pointer(unsafe.SliceData(buf))
	encodeStringUnsafeQuantum(t, op, ip)
	b0 := *(*byte)(unsafe.Add(ip, 3))
	*(*uint32)(unsafe.Add(op, 4)) = uint32(t.encQuad[int(b0>>2)<<6|int((b0&0x03)<<4)]) | uint32('=')<<16 | uint32('=')<<24
	return buf
}

func encodeBytesStdPadded5Fast(t *encodingTables, src []byte) []byte {
	buf := make([]byte, 8)
	ip := unsafe.Pointer(unsafe.SliceData(src))
	op := unsafe.Pointer(unsafe.SliceData(buf))
	encodeStringUnsafeQuantum(t, op, ip)
	b0 := *(*byte)(unsafe.Add(ip, 3))
	b1 := *(*byte)(unsafe.Add(ip, 4))
	*(*uint32)(unsafe.Add(op, 4)) = uint32(t.encQuad[int(b0)<<4|int(b1>>4)]) | uint32(t.encode[(b1&0x0f)<<2])<<16 | uint32('=')<<24
	return buf
}

func encodeBytesStdPadded6Fast(t *encodingTables, src []byte) []byte {
	buf := new([8]byte)
	ip := unsafe.Pointer(unsafe.SliceData(src))
	op := unsafe.Pointer(&buf[0])
	encodeStringUnsafeQuantum(t, op, ip)
	val := uint32(src[3])<<16 | uint32(src[4])<<8 | uint32(src[5])
	putUint32LE(buf[4:], t.encQuad[val>>12]|t.encQuad[val&0x0fff]<<16)
	return buf[:]
}

func encodeBytesStdPadded7Fast(t *encodingTables, src []byte) []byte {
	buf := make([]byte, 12)
	ip := unsafe.Pointer(unsafe.SliceData(src))
	op := unsafe.Pointer(unsafe.SliceData(buf))
	encodeStringUnsafeQuantum(t, op, ip)
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 4), unsafe.Add(ip, 3))
	b0 := *(*byte)(unsafe.Add(ip, 6))
	*(*uint32)(unsafe.Add(op, 8)) = uint32(t.encQuad[int(b0>>2)<<6|int((b0&0x03)<<4)]) | uint32('=')<<16 | uint32('=')<<24
	return buf
}

func encodeBytesStdPadded8Fast(t *encodingTables, src []byte) []byte {
	buf := make([]byte, 12)
	ip := unsafe.Pointer(unsafe.SliceData(src))
	op := unsafe.Pointer(unsafe.SliceData(buf))
	encodeStringUnsafeQuantum(t, op, ip)
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 4), unsafe.Add(ip, 3))
	b0 := *(*byte)(unsafe.Add(ip, 6))
	b1 := *(*byte)(unsafe.Add(ip, 7))
	*(*uint32)(unsafe.Add(op, 8)) = uint32(t.encQuad[int(b0)<<4|int(b1>>4)]) | uint32(t.encode[(b1&0x0f)<<2])<<16 | uint32('=')<<24
	return buf
}

func encodeBytesStdPadded9Fast(t *encodingTables, src []byte) []byte {
	buf := make([]byte, 12)
	ip := unsafe.Pointer(unsafe.SliceData(src))
	op := unsafe.Pointer(unsafe.SliceData(buf))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 0), unsafe.Add(ip, 0))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 4), unsafe.Add(ip, 3))
	encodeStringManualQuantum(t, unsafe.Add(op, 8), src[6], src[7], src[8])
	return buf
}

func encodeBytesStdPadded10Fast(t *encodingTables, src []byte) []byte {
	buf := make([]byte, 16)
	ip := unsafe.Pointer(unsafe.SliceData(src))
	op := unsafe.Pointer(unsafe.SliceData(buf))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 0), unsafe.Add(ip, 0))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 4), unsafe.Add(ip, 3))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 8), unsafe.Add(ip, 6))
	b0 := src[9]
	*(*uint32)(unsafe.Add(op, 12)) = uint32(t.encQuad[int(b0>>2)<<6|int((b0&0x03)<<4)]) | uint32('=')<<16 | uint32('=')<<24
	return buf
}

func encodeBytesStdPadded11Fast(t *encodingTables, src []byte) []byte {
	buf := new([16]byte)
	ip := unsafe.Pointer(unsafe.SliceData(src))
	op := unsafe.Pointer(&buf[0])
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 0), unsafe.Add(ip, 0))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 4), unsafe.Add(ip, 3))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 8), unsafe.Add(ip, 6))
	b0, b1 := src[9], src[10]
	*(*uint32)(unsafe.Add(op, 12)) = uint32(t.encQuad[int(b0)<<4|int(b1>>4)]) | uint32(t.encode[(b1&0x0f)<<2])<<16 | uint32('=')<<24
	return buf[:]
}

func encodeBytesStdPadded12Fast(t *encodingTables, src []byte) []byte {
	buf := make([]byte, 16)
	ip := unsafe.Pointer(unsafe.SliceData(src))
	op := unsafe.Pointer(unsafe.SliceData(buf))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 0), unsafe.Add(ip, 0))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 4), unsafe.Add(ip, 3))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 8), unsafe.Add(ip, 6))
	encodeStringManualQuantum(t, unsafe.Add(op, 12), src[9], src[10], src[11])
	return buf
}

func encodeBytesStdPadded13Fast(t *encodingTables, src []byte) []byte {
	buf := make([]byte, 20)
	ip := unsafe.Pointer(unsafe.SliceData(src))
	op := unsafe.Pointer(unsafe.SliceData(buf))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 0), unsafe.Add(ip, 0))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 4), unsafe.Add(ip, 3))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 8), unsafe.Add(ip, 6))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 12), unsafe.Add(ip, 9))
	b0 := src[12]
	*(*uint32)(unsafe.Add(op, 16)) = uint32(t.encQuad[int(b0>>2)<<6|int((b0&0x03)<<4)]) | uint32('=')<<16 | uint32('=')<<24
	return buf
}

func encodeBytesStdPadded14Fast(t *encodingTables, src []byte) []byte {
	buf := make([]byte, 20)
	ip := unsafe.Pointer(unsafe.SliceData(src))
	op := unsafe.Pointer(unsafe.SliceData(buf))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 0), unsafe.Add(ip, 0))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 4), unsafe.Add(ip, 3))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 8), unsafe.Add(ip, 6))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 12), unsafe.Add(ip, 9))
	b0, b1 := src[12], src[13]
	*(*uint32)(unsafe.Add(op, 16)) = uint32(t.encQuad[int(b0)<<4|int(b1>>4)]) | uint32(t.encode[(b1&0x0f)<<2])<<16 | uint32('=')<<24
	return buf
}

func encodeBytesStdPadded15Fast(t *encodingTables, src []byte) []byte {
	buf := make([]byte, 20)
	ip := unsafe.Pointer(unsafe.SliceData(src))
	op := unsafe.Pointer(unsafe.SliceData(buf))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 0), unsafe.Add(ip, 0))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 4), unsafe.Add(ip, 3))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 8), unsafe.Add(ip, 6))
	encodeStringUnsafeQuantum(t, unsafe.Add(op, 12), unsafe.Add(ip, 9))
	encodeStringManualQuantum(t, unsafe.Add(op, 16), src[12], src[13], src[14])
	return buf
}