} else if immh>>1 == 1 {
			return H0 + Reg(Rd)
		} else if immh>>2 == 1 {
			return S0 + Reg(Rd)
		} else {
			return nil
		}

	case arg_Vd_19_4__B_1__H_2__S_4__D_8:
		immh := (x >> 19) & (1<<4 - 1)
		Rd := x & (1<<5 - 1)
		if immh == 1 {
			return B0 + Reg(Rd)
		} else if immh>>1 == 1 {
			return H0 + Reg(Rd)
		} else if immh>>2 == 1 {
			return S0 + Reg(Rd)
		} else if immh>>3 == 1 {

		if ins.rd == obj.REG_NONE {
			ins.rd = ins.rs1
		}
		ins.imm = -1

	case ASEQZ:
		// SEQZ rs, rd -> SLTIU $1, rs, rd
		ins.as = ASLTIU
		ins.rs1, ins.rs2 = uint32(p.From.Reg), obj.REG_NONE
		ins.imm = 1

	case ASNEZ:
		// SNEZ rs, rd -> SLTU rs, x0, rd
		ins.as = ASLTU
		ins.rs1 = REG_ZERO

	case AFABSS:
		// FABSS rs, rd -> FSGNJXS rs, rs, rd
		ins.as = AFSGNJXS

	}
	en.Flush()
}

func BenchmarkDecodeBaseOptions(b *testing.B) {
	v := BaseOptions{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	rd := msgp.NewEndlessReader(buf.Bytes(), b)
	dc := msgp.NewReader(rd)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		err := v.DecodeMsg(dc)
		if err != nil {
			b.Fatal(err)
		}
	}
}

				}
				rd.Headers.Request = h
			case k8s.HTTPRouteFilterResponseHeaderModifier:
				h := createHeadersFilter(filter.ResponseHeaderModifier)
				if h == nil {
					continue
				}
				if rd.Headers == nil {
					rd.Headers = &istio.Headers{}
				}
				rd.Headers.Response = h
			default:
				return nil, nil, &ConfigError{Reason: InvalidFilter, Message: fmt.Sprintf("unsupported filter type %q", filter.Type)}
			}

			v = int32(p.To.Target().Pc-p.Pc) >> 2
		}
		as, rd, rj, width := p.As, p.Reg, p.From.Reg, 16
		switch as {
		case ABGTZ, ABLEZ:
			rd, rj = rj, rd
		case ABFPT, ABFPF:
			width = 21
			// FCC0 is the implicit source operand, now that we
			// don't register-allocate from the FCC bank.
			rd = REG_FCC0
		case ABEQ, ABNE:
			if rd == 0 || rd == REGZERO || rj == REGZERO {

	}
	if err := gopts.SetMatchETag(srcObjInfo.ETag); err != nil {
		return err
	}
	rd, objInfo, _, err := core.GetObject(ctx, srcBucket, srcObject, gopts)
	if err != nil {
		return ErrorRespToObjectError(err, srcBucket, srcObject, srcObjInfo.VersionID)
	}
	defer rd.Close()

	hr, err := hash.NewReader(ctx, rd, objInfo.Size, "", "", objInfo.Size)
	if err != nil {
		return err
	}

	}

	acctInfo := madmin.AccountInfo{
		AccountName: accountName,
		Server:      objectAPI.BackendInfo(),
		Policy:      buf,
	}

	for _, bucket := range buckets {
		rd, wr := isAllowedAccess(bucket.Name)
		if rd || wr {
			// Fetch the data usage of the current bucket
			var size uint64
			var objectsCount uint64
			var objectsHist, versionsHist map[string]uint64

			Versioned: true,
			VersionID: objInfo.VersionID,
		}); err != nil {
			t.Fatal(err)
		}
	}

	setDisks(nil, nil, nil, nil)

	rd := mustGetPutObjReader(t, bytes.NewReader(data), int64(len(data)), "", "")
	_, err = objLayer.PutObject(ctx, bucket, object, rd, ObjectOptions{
		Versioned: true,
	})
	if err != nil {
		t.Fatal(err)
	}

	setDisks(orgDisks[:4]...)
	disk := getDisk(0)

  && r.OutMask()&63 == 63
  => (S(LD|RD|RAD|LW|RW|RAW) x y)
(S(LD|RD|RAD|LW|RW|RAW) x (AND (MOVDconst [c]) y))
  => (S(LD|RD|RAD|LW|RW|RAW) x (ANDWconst <typ.UInt32> [int32(c&63)] y))
(S(LD|RD|RAD|LW|RW|RAW) x (ANDWconst [c] y)) && c&63 == 63
  => (S(LD|RD|RAD|LW|RW|RAW) x y)
(SLD  x (MOV(W|H|B|WZ|HZ|BZ)reg y)) => (SLD  x y)
(SRD  x (MOV(W|H|B|WZ|HZ|BZ)reg y)) => (SRD  x y)
(SRAD x (MOV(W|H|B|WZ|HZ|BZ)reg y)) => (SRAD x y)

yqHmUtT/6LXNvNaDI1fmuotSYXBuRwQgTGSM200tF3X9MxyoUAYLxplk3tAT0w/w7kF2XhOMI8+q8bKuK7wxa89zf3EDuTn7UVzyQaKogvcFjlt4GI3A1ZBOR6aR53sge/h7binu657kff/na9t0sLM68njsnknZa3WXVz1mGlaOJwq+HWsaQRCuWHhOEs83uAcXjzD1Q4Uz8twywOydOL4O2jIE++HnnvxJpFrPNhiDgcA40HKHOD1t+rd+WT4dRDqDk4lU2XDJ8Iv2zae/5VyAQOjxoZWGrgHorTz/e+8AzU8/8RsadPf+9qqBB2DQFaS7GFPMRANnl3hs49mcjZTmlFU0UwpCdnRsdjH6wSOwNlY0UwHvJkPNp3s1rvXvdfobGUh687pC971rs//vL/45++8+Gnn69QPvLZZ+My9njgwm69vabVa7WbMCSHNmE3IbCI14OfDatHyXOoy+D7KUcvl+aMbdq4IoaSQLZ5YeSObyye72...