instructions["JZ"] = x86.AJEQ   /* alternate */
	instructions["MASKMOVDQU"] = x86.AMASKMOVOU
	instructions["MOVD"] = x86.AMOVQ
	instructions["MOVDQ2Q"] = x86.AMOVQ
	instructions["MOVNTDQ"] = x86.AMOVNTO
	instructions["MOVOA"] = x86.AMOVO
	instructions["PSLLDQ"] = x86.APSLLO
	instructions["PSRLDQ"] = x86.APSRLO
	instructions["PADDD"] = x86.APADDL
	// Spellings originally used in CL 97235.

// BFX-like instructions which are in the form of "op $width, $LSB, (Reg,) Reg".
func IsARMBFX(op obj.As) bool {
	switch op {
	case arm.ABFX, arm.ABFXU, arm.ABFC, arm.ABFI:
		return true
	}
	return false
}

// IsARMFloatCmp reports whether the op is a floating comparison instruction.
func IsARMFloatCmp(op obj.As) bool {
	switch op {

	// NOT pseudo-instruction
	NOT	X5					// 93c2f2ff
	NOT	X5, X6					// 13c3f2ff

	// NEG/NEGW pseudo-instructions
	NEG	X5					// b3025040
	NEG	X5, X6					// 33035040
	NEGW	X5					// bb025040
	NEGW	X5, X6					// 3b035040

	// This jumps to the second instruction in the function (the
	// first instruction is an invisible stack pointer adjustment).
	JMP	start					// JMP	2

#
# Macosx options
#     darwin_arm64:
#
# Compiler options:
#     cuda_clang:             Use Clang when building CUDA code.
#     avx_linux:              Build with avx instruction set on linux.
#     avx_win:                Build with avx instruction set on windows
#
# Other build options:
#     short_logs:       Only log errors during build, skip warnings.
#     verbose_logs:     Show all compiler warnings during build.

// This contains the majority of valid opcode combinations
// available in cmd/internal/obj/ppc64/asm9.go with
// their valid instruction encodings.

#include "../../../../../runtime/textflag.h"

// In case of index mode instructions, usage of
// (Rx)(R0) is equivalent to (Rx+R0)
// In case of base+displacement mode instructions if
// the offset is 0, usage of (Rx) is equivalent to 0(Rx)
TEXT asmtest(SB),DUPOK|NOSPLIT,$0
	// move constants

	FTINTRNEVD	F0, F2		// 02e81a01

	// LDX.{B,BU,H,HU,W,WU,D} instructions
	MOVB		(R14)(R13), R12	// cc350038
	MOVBU		(R14)(R13), R12	// cc352038
	MOVH		(R14)(R13), R12	// cc350438
	MOVHU		(R14)(R13), R12	// cc352438
	MOVW		(R14)(R13), R12	// cc350838
	MOVWU		(R14)(R13), R12	// cc352838
	MOVV		(R14)(R13), R12	// cc350c38

	// STX.{B,H,W,D} instructions
	MOVB		R12, (R14)(R13)	// cc351038
	MOVH		R12, (R14)(R13)	// cc351438

import java.util.Map;

@GwtIncompatible
public class CompactHashMapFloodingTest extends AbstractHashFloodingTest<Map<Object, Object>> {
  public CompactHashMapFloodingTest() {
    super(
        ImmutableList.of(Construction.mapFromKeys(CompactHashMap::create)),
        n -> n * log(n),
        ImmutableList.of(QueryOp.MAP_GET));
  }

import java.util.Set;

@GwtIncompatible
public class CompactHashSetFloodingTest extends AbstractHashFloodingTest<Set<Object>> {
  public CompactHashSetFloodingTest() {
    super(
        ImmutableList.of(Construction.setFromElements(CompactHashSet::create)),
        n -> n * log(n),
        ImmutableList.of(QueryOp.SET_CONTAINS));
  }

@GwtIncompatible
public class CompactLinkedHashMapFloodingTest
    extends AbstractHashFloodingTest<Map<Object, Object>> {
  public CompactLinkedHashMapFloodingTest() {
    super(
        ImmutableList.of(Construction.mapFromKeys(CompactLinkedHashMap::create)),
        n -> n * log(n),
        ImmutableList.of(QueryOp.MAP_GET));
  }

                  int unused = ms.count(o);
                },
                Math::log)));
  }

  /** All the ways to create an ImmutableMultiset. */
  enum ConstructionPathway implements Construction<Multiset<Object>> {
    COPY_OF_COLLECTION {
      @Override
      public ImmutableMultiset<Object> create(List<?> keys) {
        return ImmutableMultiset.copyOf(keys);
      }
    },
    COPY_OF_ITERATOR {