package des

import (
	"crypto/cipher"
	"crypto/internal/alias"
	"internal/byteorder"
	"strconv"
)

// The DES block size in bytes.
const BlockSize = 8

type KeySizeError int

func (k KeySizeError) Error() string {
	return "crypto/des: invalid key size " + strconv.Itoa(int(k))
}

// desCipher is an instance of DES encryption.
type desCipher struct {
	subkeys [16]uint64
}

type aesCipher struct {
	l   uint8 // only this length of the enc and dec array is actually used
	enc [28 + 32]uint32
	dec [28 + 32]uint32
}

type KeySizeError int

func (k KeySizeError) Error() string {
	return "crypto/aes: invalid key size " + strconv.Itoa(int(k))
}

// NewCipher creates and returns a new [cipher.Block].
// The key argument should be the AES key,

package rc4

import (
	"crypto/internal/alias"
	"strconv"
)

// A Cipher is an instance of RC4 using a particular key.
type Cipher struct {
	s    [256]uint32
	i, j uint8
}

type KeySizeError int

func (k KeySizeError) Error() string {
	return "crypto/rc4: invalid key size " + strconv.Itoa(int(k))
}

// NewCipher creates and returns a new [Cipher]. The key argument should be the

	}

	var function code
	switch len(key) {
	case 128 / 8:
		function = aes128
	case 192 / 8:
		function = aes192
	case 256 / 8:
		function = aes256
	default:
		return nil, KeySizeError(len(key))
	}

	var c aesCipherAsm
	c.function = function
	c.key = c.storage[:len(key)]
	copy(c.key, key)
	return &c, nil
}

func (c *aesCipherAsm) BlockSize() int { return BlockSize }

	var rounds int
	switch len(key) {
	case 128 / 8:
		rounds = 10
	case 192 / 8:
		rounds = 12
	case 256 / 8:
		rounds = 14
	default:
		return nil, KeySizeError(len(key))
	}

	expandKeyAsm(rounds, &key[0], &c.enc[0], &c.dec[0])
	if supportsAES && supportsGFMUL {
		return &c, nil
	}
	return &c.aesCipherAsm, nil
}

		{"SHA512", Const, 0},
		{"SHA512_224", Const, 5},
		{"SHA512_256", Const, 5},
		{"Signer", Type, 4},
		{"SignerOpts", Type, 4},
	},
	"crypto/aes": {
		{"(KeySizeError).Error", Method, 0},
		{"BlockSize", Const, 0},
		{"KeySizeError", Type, 0},
		{"NewCipher", Func, 0},
	},
	"crypto/cipher": {
		{"(StreamReader).Read", Method, 0},
		{"(StreamWriter).Close", Method, 0},

pkg crypto, type Hash uint
pkg crypto, type PrivateKey interface {}
pkg crypto/aes, const BlockSize ideal-int
pkg crypto/aes, func NewCipher([]uint8) (cipher.Block, error)
pkg crypto/aes, method (KeySizeError) Error() string
pkg crypto/aes, type KeySizeError int
pkg crypto/cipher, func NewCBCDecrypter(Block, []uint8) BlockMode
pkg crypto/cipher, func NewCBCEncrypter(Block, []uint8) BlockMode
pkg crypto/cipher, func NewCFBDecrypter(Block, []uint8) Stream