0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1c, 0x0a, 0x09,
	0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0c, 0x52,
	0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x68, 0x6f,
	0x73, 0x74, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x15, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x68, 0x6f,

	SIGEMT     = Signal(0x7)
	SIGFPE     = Signal(0x8)
	SIGFREEZE  = Signal(0x22)
	SIGHUP     = Signal(0x1)
	SIGILL     = Signal(0x4)
	SIGINT     = Signal(0x2)
	SIGIO      = Signal(0x16)
	SIGIOT     = Signal(0x6)
	SIGJVM1    = Signal(0x27)
	SIGJVM2    = Signal(0x28)
	SIGKILL    = Signal(0x9)
	SIGLOST    = Signal(0x25)
	SIGLWP     = Signal(0x21)
	SIGPIPE    = Signal(0xd)
	SIGPOLL    = Signal(0x16)

DATA masks<>+0x00(SB)/8, $0x0000000000000000
DATA masks<>+0x08(SB)/8, $0x0000000000000000
DATA masks<>+0x10(SB)/8, $0x00000000000000ff
DATA masks<>+0x18(SB)/8, $0x0000000000000000
DATA masks<>+0x20(SB)/8, $0x000000000000ffff
DATA masks<>+0x28(SB)/8, $0x0000000000000000
DATA masks<>+0x30(SB)/8, $0x0000000000ffffff
DATA masks<>+0x38(SB)/8, $0x0000000000000000
DATA masks<>+0x40(SB)/8, $0x00000000ffffffff

	switch a {
	case AADD:
		return 0x20 << 15
	case AADDU:
		return 0x20 << 15
	case ASGT:
		return 0x24 << 15 // SLT
	case ASGTU:
		return 0x25 << 15 // SLTU
	case AMASKEQZ:
		return 0x26 << 15
	case AMASKNEZ:
		return 0x27 << 15
	case AAND:
		return 0x29 << 15
	case AOR:
		return 0x2a << 15
	case AXOR:
		return 0x2b << 15
	case ASUB:
		return 0x22 << 15

		{"Even255", "0x82828282828200FFFF28FF2B218281FF8000000000000000000000000000000000000000000000000000000000000000"},
		{"SmallEven1", "0x7E"},
		{"SmallEven2", "0x7C"},
		{"SmallEven3", "0x78"},
		{"SmallEven4", "0x70"},
	}
	for _, mod := range mods {
		n, _ := new(Int).SetString(mod.val, 0)
		out := new(Int)
		b.Run(mod.name, func(b *testing.B) {
			b.ReportAllocs()

	}
}

// Tests that ranges are ignored with serving empty content. (Issue 54794)
func TestServeContentWithEmptyContentIgnoreRanges(t *testing.T) {
	for _, r := range []string{
		"bytes=0-128",
		"bytes=1-",
	} {
		rec := httptest.NewRecorder()
		req := httptest.NewRequest("GET", "/", nil)
		req.Header.Set("Range", r)
		ServeContent(rec, req, "nothing", time.Now(), bytes.NewReader(nil))

func marshalCertificatePolicies(policies []OID, policyIdentifiers []asn1.ObjectIdentifier) (pkix.Extension, error) {
	ext := pkix.Extension{Id: oidExtensionCertificatePolicies}

	b := cryptobyte.NewBuilder(make([]byte, 0, 128))
	b.AddASN1(cryptobyte_asn1.SEQUENCE, func(child *cryptobyte.Builder) {
		if x509usepolicies.Value() == "1" {
			x509usepolicies.IncNonDefault()
			for _, v := range policies {