"RLDCRCC",
	"RLDICR",
	"RLDICRCC",
	"RLDCL",
	"RLDCLCC",
	"RLDICL",
	"RLDICLCC",
	"RLDIC",
	"RLDICCC",
	"CLRLSLDI",
	"ROTL",
	"ROTLW",
	"SLBIA",
	"SLBIE",
	"SLBMFEE",
	"SLBMFEV",
	"SLBMTE",
	"SLD",
	"SLDCC",
	"SRD",
	"SRAD",
	"SRADCC",
	"SRDCC",
	"EXTSWSLI",
	"EXTSWSLICC",
	"STDCCC",
	"TD",
	"SETB",
	"DWORD",
	"REMD",
	"REMDU",

	TLBSYNC                         // 7c00046c
	HRFID                           // 4c000224
	SLBIA                           // 7c0003e4
	SLBIE R3                        // 7c001b64
	SLBMFEE R3, R4                  // 7c801f26
	SLBMFEV R3, R4                  // 7c801ea6
	SLBMTE R3, R4                   // 7c801b24

	TW $31, R0, R0                  // 7fe00008
	TD $31, R0, R0                  // 7fe00088

	FRSQRTES:       "frsqrtes",
	FRSQRTESCC:     "frsqrtes.",
	HRFID:          "hrfid",
	POPCNTB:        "popcntb",
	MFOCRF:         "mfocrf",
	MTOCRF:         "mtocrf",
	SLBMFEE:        "slbmfee",
	SLBMFEV:        "slbmfev",
	SLBMTE:         "slbmte",
	RFSCV:          "rfscv",
	SCV:            "scv",
	LQ:             "lq",
	STQ:            "stq",
	CNTLZD:         "cntlzd",
	CNTLZDCC:       "cntlzd.",

			o1 = AOP_IRR(c.opirr(p.As), r, uint32(p.From.Reg), uint32(uint16(p.To.Offset)))
		} else {
			o1 = AOP_RRR(c.oprrr(p.As), r, uint32(p.From.Reg), uint32(p.To.Reg))
		}

	case 72: /* slbmte (Rb+Rs -> slb[Rb]) -> Rs, Rb */
		o1 = AOP_RRR(c.oprrr(p.As), uint32(p.From.Reg), 0, uint32(p.To.Reg))

	case 73: /* mcrfs crfD,crfS */

		ppc64.AEXTSBCC, ppc64.AEXTSB, ppc64.AEXTSHCC, ppc64.AEXTSH,
		ppc64.AEXTSWCC, ppc64.AEXTSW, ppc64.ANEGCC, ppc64.ANEGVCC,
		ppc64.ANEGV, ppc64.ANEG, ppc64.ASLBMFEE, ppc64.ASLBMFEV,
		ppc64.ASLBMTE, ppc64.ASUBMECC, ppc64.ASUBMEVCC, ppc64.ASUBMEV,
		ppc64.ASUBME, ppc64.ASUBZECC, ppc64.ASUBZEVCC, ppc64.ASUBZEV,
		ppc64.ASUBZE:
		return true
	}
	return false
}

		})

	})

	b.Run("Grow", func(b *testing.B) {
		const C = 5

		b.Run("Byte", func(b *testing.B) {
			for i := 0; i < b.N; i++ {
				sByte = make([]byte, 0)
				for j := 0; j < C; j++ {
					sByte = append(sByte, 0x77)
					sByte = sByte[:cap(sByte)]
				}
			}
		})

		b.Run("1Ptr", func(b *testing.B) {
			for i := 0; i < b.N; i++ {
				s1Ptr = make([]uintptr, 0)

	// greatly between runs with different PRNG seeds.
	src := rand.NewSource(1)

	// The undirected graphs, friends and enemies, are the political relationships
	// in the Middle East as described in the Slate article:
	// http://www.slate.com/blogs/the_world_/2014/07/17/the_middle_east_friendship_chart.html
	g, err := community.NewUndirectedLayers(friends, enemies)
	if err != nil {
		log.Fatal(err)
	}
	weights := []float64{1, -1}

// Returns the Azure tags
func (e *azureEnv) azureTags() map[string]string {
	tags := map[string]string{}
	if tl, ok := e.computeMetadata["tagsList"]; ok {
		tlByte, err := json.Marshal(tl)
		if err != nil {
			return tags
		}
		var atl []azureTag
		err = json.Unmarshal(tlByte, &atl)
		if err != nil {
			return tags
		}
		for _, tag := range atl {
			tags[e.prefixName(tag.Name)] = tag.Value
		}
		return tags
	}

	// greatly between runs with different PRNG seeds.
	src := rand.NewSource(1)

	// The undirected graphs, friends and enemies, are the political relationships
	// in the Middle East as described in the Slate article:
	// http://www.slate.com/blogs/the_world_/2014/07/17/the_middle_east_friendship_chart.html
	g, err := community.NewUndirectedLayers(friends, enemies)
	if err != nil {
		log.Fatal(err)
	}
	weights := []float64{1, -1}

	// is evicted from the cache, then the allowance for that bucket is reset. If
	// more queries are later received for an evicted bucket, then that bucket
	// will re-enter the cache with a clean slate, giving that bucket a full
	// allowance of burst queries.
	//
	// The default cache size is 4096.
	//
	// If limitType is 'server', then cacheSize is ignored.
	// +optional