err = msgp.WrapError(err, "StartTime")
				return
			}
		case "lu":
			z.LastUpdate, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "LastUpdate")
				return
			}
		case "ra":
			z.RetryAttempts, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "RetryAttempts")
				return
			}
		case "at":
			z.Attempts, err = dc.ReadInt()
			if err != nil {

        map.put("モ", new String[] { "mo" });

        map.put("ヤ", new String[] { "ya" });
        map.put("ユ", new String[] { "yu" });
        map.put("ヨ", new String[] { "yo" });

        map.put("ラ", new String[] { "ra" });
        map.put("リ", new String[] { "ri" });
        map.put("ル", new String[] { "ru" });
        map.put("レ", new String[] { "re" });
        map.put("ロ", new String[] { "ro" });

		pool := globalBytePoolCap.Load()
		bufA := pool.Get()
		bufB := pool.Get()
		defer pool.Put(bufA)
		defer pool.Put(bufB)
		ra, err := readahead.NewReaderBuffer(data, [][]byte{bufA[:fi.Erasure.BlockSize], bufB[:fi.Erasure.BlockSize]})
		if err == nil {
			toEncode = ra
			defer ra.Close()
		}
	}

	n, err := erasure.Encode(ctx, toEncode, writers, buffer, writeQuorum)
	closeErrs := closeBitrotWriters(writers)

		Transport:       tr,
	})
}

func (f *sftpDriver) AccessKey() string {
	return f.permissions.CriticalOptions["AccessKey"]
}

func (f *sftpDriver) Fileread(r *sftp.Request) (ra io.ReaderAt, err error) {
	// This is not timing the actual read operation, but the time it takes to prepare the reader.
	stopFn := globalSftpMetrics.log(r, f.AccessKey())
	defer stopFn(0, err)

	flags := r.Pflags()

				if err != nil {
					return err
				}
				if st, err := f.Stat(); err == nil {
					sz = st.Size()
				}
				defer f.Close()
				r = f
			}
			if ra, ok := r.(io.ReaderAt); ok && strings.HasSuffix(file, ".zip") {
				zr, err := zip.NewReader(ra, sz)
				if err != nil {
					return err
				}
				for _, file := range zr.File {
					if file.FileInfo().IsDir() {
						continue
					}

	for i := riscv.REG_V0; i <= riscv.REG_V31; i++ {
		name := fmt.Sprintf("V%d", i-riscv.REG_V0)
		register[name] = int16(i)
	}

	// General registers with ABI names.
	register["ZERO"] = riscv.REG_ZERO
	register["RA"] = riscv.REG_RA
	register["SP"] = riscv.REG_SP
	register["GP"] = riscv.REG_GP
	register["TP"] = riscv.REG_TP
	register["T0"] = riscv.REG_T0
	register["T1"] = riscv.REG_T1
	register["T2"] = riscv.REG_T2