return config.DefaultHelpPostfix(DefaultKVS, key)
	}

	// Help provides help for config values
	Help = config.HelpKVS{
		config.HelpKV{
			Key:         Bitrot,
			Description: `perform bitrot scan on drives when checking objects during scanner` + defaultHelpPostfix(Bitrot),
			Optional:    true,
			Type:        "on|off",
		},
		config.HelpKV{
			Key:         Sleep,

	storageRESTDstPath       = "destination-path"
	storageRESTOffset        = "offset"
	storageRESTLength        = "length"
	storageRESTCount         = "count"
	storageRESTBitrotAlgo    = "bitrot-algo"
	storageRESTBitrotHash    = "bitrot-hash"
	storageRESTDiskID        = "disk-id"
	storageRESTForceDelete   = "force-delete"
	storageRESTGlob          = "glob"
	storageRESTMetrics       = "metrics"
	storageRESTDriveQuorum   = "drive-quorum"

	var x72 uint64
	x72, x71 = bits.Mul64(x1, arg2[4])
	var x73 uint64
	var x74 uint64
	x74, x73 = bits.Mul64(x1, arg2[3])
	var x75 uint64
	var x76 uint64
	x76, x75 = bits.Mul64(x1, arg2[2])
	var x77 uint64
	var x78 uint64
	x78, x77 = bits.Mul64(x1, arg2[1])
	var x79 uint64
	var x80 uint64
	x80, x79 = bits.Mul64(x1, arg2[0])
	var x81 uint64
	var x82 uint64
	x81, x82 = bits.Add64(x80, x77, uint64(0x0))

	var x39 uint64
	var x40 uint64
	x39, x40 = bits.Add64(x17, x30, uint64(p224Uint1(x38)))
	var x41 uint64
	var x42 uint64
	x41, x42 = bits.Add64(x19, x32, uint64(p224Uint1(x40)))
	var x43 uint64
	var x44 uint64
	x44, x43 = bits.Mul64(x1, arg2[3])
	var x45 uint64
	var x46 uint64
	x46, x45 = bits.Mul64(x1, arg2[2])
	var x47 uint64
	var x48 uint64

	x105, x104 = bits.Mul64(x1, arg2[6])
	var x106 uint64
	var x107 uint64
	x107, x106 = bits.Mul64(x1, arg2[5])
	var x108 uint64
	var x109 uint64
	x109, x108 = bits.Mul64(x1, arg2[4])
	var x110 uint64
	var x111 uint64
	x111, x110 = bits.Mul64(x1, arg2[3])
	var x112 uint64
	var x113 uint64
	x113, x112 = bits.Mul64(x1, arg2[2])
	var x114 uint64
	var x115 uint64
	x115, x114 = bits.Mul64(x1, arg2[1])

			name: "RotateLeft",
			in:   15,
			out:  [4]any{bits.RotateLeft8(15, 2), bits.RotateLeft16(15, 2), bits.RotateLeft32(15, 2), bits.RotateLeft64(15, 2)},
			out2: [4]any{bits.RotateLeft8(15, -2), bits.RotateLeft16(15, -2), bits.RotateLeft32(15, -2), bits.RotateLeft64(15, -2)},
		},
		{
			name: "Reverse",
			in:   19,
			out:  [4]any{bits.Reverse8(19), bits.Reverse16(19), bits.Reverse32(19), bits.Reverse64(19)},
		},
		{
			name: "ReverseBytes",

	x37, x38 = bits.Add64(x19, x21, uint64(p256Uint1(x36)))
	var x39 uint64
	var x40 uint64
	x40, x39 = bits.Mul64(x1, arg2[3])
	var x41 uint64
	var x42 uint64
	x42, x41 = bits.Mul64(x1, arg2[2])
	var x43 uint64
	var x44 uint64
	x44, x43 = bits.Mul64(x1, arg2[1])
	var x45 uint64
	var x46 uint64
	x46, x45 = bits.Mul64(x1, arg2[0])
	var x47 uint64
	var x48 uint64
	x47, x48 = bits.Add64(x46, x43, uint64(0x0))

}

// Count counts number of bits in mask set to one
func (s *bitMask) Count() int {
	return bits.OnesCount64(uint64(*s))
}

// Getbits returns each bit number with bits set to one
func (s *bitMask) GetBits() []int {
	var bits []int
	for i := uint64(0); i < 64; i++ {
		if (*s & (1 << i)) > 0 {
			bits = append(bits, int(i))
		}
	}
	return bits
}

		bc4 = bits.RotateLeft64(t, 18)
		t = a[1] ^ d1
		bc0 = bits.RotateLeft64(t, 1)
		t = a[7] ^ d2
		bc1 = bits.RotateLeft64(t, 6)
		t = a[13] ^ d3
		bc2 = bits.RotateLeft64(t, 25)
		t = a[19] ^ d4
		bc3 = bits.RotateLeft64(t, 8)
		a[20] = bc0 ^ (bc2 &^ bc1)
		a[1] = bc1 ^ (bc3 &^ bc2)
		a[7] = bc2 ^ (bc4 &^ bc3)
		a[13] = bc3 ^ (bc0 &^ bc4)
		a[19] = bc4 ^ (bc1 &^ bc0)

		t = a[5] ^ d0

[{"Name":"ADC","Bits":"0|0|0|1|1|0|1|0|0|0|0|Rm:5|0|0|0|0|0|0|Rn:5|Rd:5","Arch":"32-bit variant","Syntax":"ADC <Wd>, <Wn>, <Wm>","Code":"","Alias":""},
{"Name":"ADC","Bits":"1|0|0|1|1|0|1|0|0|0|0|Rm:5|0|0|0|0|0|0|Rn:5|Rd:5","Arch":"64-bit variant","Syntax":"ADC <Xd>, <Xn>, <Xm>","Code":"","Alias":""},
{"Name":"ADCS","Bits":"0|0|1|1|1|0|1|0|0|0|0|Rm:5|0|0|0|0|0|0|Rn:5|Rd:5","Arch":"32-bit variant","Syntax":"ADCS <Wd>, <Wn>, <Wm>","Code":"","Alias":""},