val b0 = this[index].code
  val b1 = this[index + 1].code
  return (b0 shl 7) + b1
}

/**
 * An extremely generic binary search that doesn't know what data it's searching over. The caller
 * provides indexes and a comparison function, and this calls that function iteratively.
 *
 * @return the index of the match. If no match is found this is `(-1 - insertionPoint)`, where the

		GrouplessAPIPrefixes: sets.NewString("api"),
	}

	for _, testCase := range testCases {
		t.Run(testCase.name, func(t *testing.T) {
			watchTracker := &watchTracker{
				indexes:    getBuiltinIndexes(),
				watchCount: make(map[watchIdentifier]int),
			}

			requestInfo, err := requestInfoFactory.NewRequestInfo(testCase.request)
			if err != nil {

   * they're defined above -- including logic to add and subtract 1 to map between the values stored
   * in the predecessor/successor arrays and the indexes in the elements array that they identify.
   */

   * they're defined above -- including logic to add and subtract 1 to map between the values stored
   * in the predecessor/successor arrays and the indexes in the elements array that they identify.
   */

    primary: teal
    accent: amber
    toggle:
      icon: material/lightbulb-outline
      name: Switch to light mode
  features:
  - search.suggest
  - search.highlight
  - content.tabs.link
  - navigation.indexes
  - content.tooltips
  - navigation.path
  - content.code.annotate
  - content.code.copy
  - content.code.select
  - navigation.tabs
  icon:
    repo: fontawesome/brands/github-alt
  logo: img/icon-white.svg

    // satisfy the same operands and results constraint. The keys of this map
    // are the values from `operand_states_` and `result_state_`.
    std::unordered_map<int, RequantizeState> rescale_states_;

    // Maps of indexes to the propagation state vector from the ops operands,
    // results and arguments.
    llvm::DenseMap<OpValue, int> operand_states_;
    llvm::DenseMap<OpValue, int> result_states_;
  };

  func::FuncOp func_;

// AddPod, UpdatePod, or RemovePod.
type basicManager struct {
	// Protects all internal maps.
	lock sync.RWMutex

	// Regular pods indexed by UID.
	podByUID map[kubetypes.ResolvedPodUID]*v1.Pod
	// Mirror pods indexed by UID.
	mirrorPodByUID map[kubetypes.MirrorPodUID]*v1.Pod

	// Pods indexed by full name for easy access.
	podByFullName       map[string]*v1.Pod
	mirrorPodByFullName map[string]*v1.Pod

#### Endpoints

        source.iteratorNoFlush().collect() == ["bazz", "buzz"]

        and:
        source.iterator().collect() == ["bazz", "bar", "baz", "buzz", "buzz"]
    }

    def "listIterator provides accurate indexes"() {
        given:
        source.add("foo")
        source.addPending(provider("bar"))
        source.addPendingCollection(listProvider("baz", "buzz"))
        source.add("fizz")

        when:

    ShapedType input_type, ShapedType output_type) {
  ArrayRef<int64_t> in_shape = input_type.getShape();
  ArrayRef<int64_t> out_shape = output_type.getShape();

  // Get the indexes of the non-identity dimensions and the identity dimensions
  // in the input shape.
  SmallVector<int32_t> input_nonidentity_dims_index_array;
  SmallVector<int32_t> input_identity_dims_index_array;