*         <td>"x86_64", "amd64", "x64", "x86-64"</td>
 *     </tr>
 *     <tr>
 *         <td>Intel Itanium</td>
 *         <td>N/A</td>
 *         <td>"ia-64", "ia64"</td>
 *     </tr>
 *     <tr>
 *         <td>Power PC</td>
 *         <td>"ppc"</td>
 *         <td>"ppc64"</td>
 *     </tr>
 *     <tr>
 *         <td>Sparc</td>
 *         <td>"sparc", "sparc32", "sparc-v8"</td>

we should do this.
  But, in a larger sense, we can not dedicate - we can not
consecrate - we can not hallow - this ground.
  The brave men, living and dead, who struggled here, have
consecrated it, far above our poor power to add or detract.
The world will little note, nor long remember what we say here,
but it can never forget what they did here.
  It is for us the living, rather, to be dedicated here to the

					return chunk, nil
				}

				words := len(data) / 8
				if !isPowerOf2(words) {
					t.Errorf("read %d 8-byte words, but each write is a power-of-2 number of words", words)
					return chunk, nil
				}

				u := binary.LittleEndian.Uint64(data)
				for i := 1; i < words; i++ {
					next := binary.LittleEndian.Uint64(data[i*8:])
					if next != u+1 {

	return traceArg(uint64(base)-trace.minPageHeapAddr) / fixedStack
}

// traceCompressStackSize assumes size is a power of 2 and returns log2(size).
func traceCompressStackSize(size uintptr) traceArg {
	if size&(size-1) != 0 {
		throw("goroutine stack size is not a power of 2")
	}
	return traceArg(sys.Len64(uint64(size)))

  }

  private static final int MAX_TABLE_SIZE = Ints.MAX_POWER_OF_TWO;

  static int closedTableSize(int expectedEntries, double loadFactor) {
    // Get the recommended table size.
    // Round down to the nearest power of 2.
    expectedEntries = Math.max(expectedEntries, 2);
    int tableSize = Integer.highestOneBit(expectedEntries);
    // Check to make sure that we will not exceed the maximum load factor.

)

// TimeHistogram is an high-dynamic-range histogram for durations.
type TimeHistogram struct {
	Count                int
	Buckets              []int
	MinBucket, MaxBucket int
}

// Five buckets for every power of 10.
var logDiv = math.Log(math.Pow(10, 1.0/5))

// Add adds a single sample to the histogram.
func (h *TimeHistogram) Add(d time.Duration) {
	var bucket int
	if d > 0 {
		bucket = int(math.Log(float64(d)) / logDiv)

// license that can be found in the LICENSE file.

//go:build ppc64 || ppc64le

package bytealg

import "internal/cpu"

const MaxBruteForce = 16

var SupportsPower9 = cpu.PPC64.IsPOWER9

func init() {
	MaxLen = 32
}

// Cutover reports the number of failures of IndexByte we should tolerate
// before switching over to Index.
// n is the number of bytes processed so far.

  }

  private static final int MAX_TABLE_SIZE = Ints.MAX_POWER_OF_TWO;

  static int closedTableSize(int expectedEntries, double loadFactor) {
    // Get the recommended table size.
    // Round down to the nearest power of 2.
    expectedEntries = Math.max(expectedEntries, 2);
    int tableSize = Integer.highestOneBit(expectedEntries);
    // Check to make sure that we will not exceed the maximum load factor.

	// CPU features
	_PPC_FEATURE2_DARN = 0x00200000
	_PPC_FEATURE2_SCV  = 0x00100000
)

func doinit() {
	// HWCAP2 feature bits
	PPC64.IsPOWER8 = isSet(hwCap2, _PPC_FEATURE2_ARCH_2_07)
	PPC64.IsPOWER9 = isSet(hwCap2, _PPC_FEATURE2_ARCH_3_00)
	PPC64.HasDARN = isSet(hwCap2, _PPC_FEATURE2_DARN)
	PPC64.HasSCV = isSet(hwCap2, _PPC_FEATURE2_SCV)
}

func isSet(hwc uint, value uint) bool {
	return hwc&value != 0

	_IMPL_POWER9 = 0x20000
)

func archInit() {
	impl := getsystemcfg(_SC_IMPL)
	if impl&_IMPL_POWER8 != 0 {
		PPC64.IsPOWER8 = true
	}
	if impl&_IMPL_POWER9 != 0 {
		PPC64.IsPOWER8 = true
		PPC64.IsPOWER9 = true
	}

	Initialized = true
}

func getsystemcfg(label int) (n uint64) {
	r0, _ := callgetsystemcfg(label)
	n = uint64(r0)
	return