"policewoman":                          "\U0001f46e\u200d\u2640\ufe0f",
	"poodle":                               "\U0001f429",
	"poop":                                 "\U0001f4a9",
	"popcorn":                              "\U0001f37f",
	"portugal":                             "\U0001f1f5\U0001f1f9",
	"post_office":                          "\U0001f3e3",
	"postal_horn":                          "\U0001f4ef",

}

// TrailingZeros64 returns the number of trailing zero bits in x; the result is 64 for x == 0.
func TrailingZeros64(x uint64) int {
	if x == 0 {
		return 64
	}
	// If popcount is fast, replace code below with return popcount(^x & (x - 1)).
	//
	// x & -x leaves only the right-most bit set in the word. Let k be the
	// index of that bit. Since only a single bit is set, the value is two

}

// TrailingZeros64 returns the number of trailing zero bits in x; the result is 64 for x == 0.
func TrailingZeros64(x uint64) int {
	if x == 0 {
		return 64
	}
	// If popcount is fast, replace code below with return popcount(^x & (x - 1)).
	//
	// x & -x leaves only the right-most bit set in the word. Let k be the
	// index of that bit. Since only a single bit is set, the value is two

	// arm64:`EON\t`,-`EOR`,-`MVN`
	a[1] = ^(y ^ z)

	// arm64:`EON\t`,-`XOR`
	a[2] = x ^ ^z

	// arm64:`EON\t`,-`EOR`,-`MVN`
	return n ^ (m ^ 0xffffffffffffffff)
}

func op_orn(x, y uint32) uint32 {
	// arm64:`ORN\t`,-`ORR`
	return x | ^y
}

// check bitsets
func bitSetPowerOf2Test(x int) bool {
	// amd64:"BTL\t[$]3"
	return x&8 == 8
}

1F37D         ; valid                  ;      ; NV8    # 7.0  FORK AND KNIFE WITH PLATE
1F37E..1F37F  ; valid                  ;      ; NV8    # 8.0  BOTTLE WITH POPPING CORK..POPCORN
1F380..1F393  ; valid                  ;      ; NV8    # 6.0  RIBBON..GRADUATION CAP
1F394..1F39F  ; valid                  ;      ; NV8    # 7.0  HEART WITH TIP ON THE LEFT..ADMISSION TICKETS

    // The ellipsis fill might exceed the current output shape because we are
    // also taking account of any to-be-inserted new axes.
    const int ellipsis_filled_dim_size =
        input_size - begin_shape[0] + 1 + absl::popcount(new_axis_mask);

    int64_t begin_mask = strided_slice_op.getBeginMask();
    int64_t end_mask = strided_slice_op.getEndMask();
    int64_t revised_begin_mask = 0;
    int64_t revised_end_mask = 0;

(BitLen64 x) => (SUBFCconst [64] (CNTLZD <typ.Int> x))
(BitLen32 x) => (SUBFCconst [32] (CNTLZW <typ.Int> x))

(PopCount64 ...) => (POPCNTD ...)
(PopCount(32|16|8) x) => (POPCNT(W|W|B) (MOV(W|H|B)Zreg x))

(And(64|32|16|8) ...) => (AND ...)
(Or(64|32|16|8) ...) => (OR ...)
(Xor(64|32|16|8) ...) => (XOR ...)

(Neg(64|32|16|8) ...) => (NEG ...)

(BitLen8 <t> x) && buildcfg.GOAMD64 >= 3 => (NEGQ (ADDQconst <t> [-32] (LZCNTL (MOVBQZX <x.Type> x))))

(Bswap(64|32) ...) => (BSWAP(Q|L) ...)
(Bswap16 x) => (ROLWconst [8] x)

(PopCount(64|32) ...) => (POPCNT(Q|L) ...)
(PopCount16 x) => (POPCNTL (MOVWQZX <typ.UInt32> x))
(PopCount8 x) => (POPCNTL (MOVBQZX <typ.UInt32> x))

(Sqrt ...) => (SQRTSD ...)
(Sqrt32 ...) => (SQRTSS ...)

}

def TF_PopulationCountOp : TF_Op<"PopulationCount", [Pure, SameOperandsAndResultShape]> {
  let summary = [{
Computes element-wise population count (a.k.a. popcount, bitsum, bitcount).
  }];

  let description = [{
For each entry in `x`, calculates the number of `1` (on) bits in the binary
representation of that entry.