// LD1 <Vt>.H[<index_2>], [<Xn|SP>], #2
	{0xbfffe400, 0x0ddf4000, LD1, instArgs{arg_Vt_1_arrangement_H_index__Q_S_size_1, arg_Xns_mem_post_fixedimm_2}, nil},
	// LD1 <Vt>.H[<index_2>], [<Xn|SP>], #<Xm>
	{0xbfe0e400, 0x0dc04000, LD1, instArgs{arg_Vt_1_arrangement_H_index__Q_S_size_1, arg_Xns_mem_post_Xm}, nil},
	// LD1 <Vt>.S[<index_3>], [<Xn|SP>], #4

	y := [5]int64{1, 2, 3, 4, 5}
	z := "abcd"
	w := make([]byte, 4)
	w[3] = 5
	v := make(map[int]int64)
	v[3] = 18

	test(Index1(x), int64(2))
	test(Index1(y), int64(4))
	test(Index2(z), byte(100))
	test(Index2(w), byte(5))
	test(Index2a(w), byte(5))
	test(Index3(v), int64(18))
	test(Index4(v), int64(18))

	// PVs are indexed by their access modes to allow easier searching.  Each
	// index is the string representation of a set of access modes. There is a
	// finite number of possible sets and PVs will only be indexed in one of
	// them (whichever index matches the PV's modes).
	//
	// A request for resources will always specify its desired access modes.

 *            要素の型
 * @see IndexedIterator
 */
public class Indexed<T> {

    /** 要素 */
    private final T element;

    /** 要素のインデックス */
    private final int index;

    /**
     * コンストラクタ
     *
     * @param element
     *            要素
     * @param index
     *            要素のインデックス
     */
    public Indexed(final T element, final int index) {
        this.element = element;
        this.index = index;

				})

				indexes[index.Name] = idx
			}
		}
	}
	for _, index := range indexes {
		if index.Class == "UNIQUE" && len(index.Fields) == 1 {
			index.Fields[0].Field.UniqueIndex = index.Name
		}
	}
	return indexes
}

func (schema *Schema) LookIndex(name string) *Index {
	if schema != nil {
		indexes := schema.ParseIndexes()
		for _, index := range indexes {
			if index.Name == name {

      value_eq.getRhs() != body.getArgument(2))
    return failure();

  mhlo::CompareOp index_lt = llvm::dyn_cast_or_null<mhlo::CompareOp>(
      index_and.getRhs().getDefiningOp());
  if (!index_lt ||
      index_lt.getComparisonDirection() != mhlo::ComparisonDirection::LT ||
      index_lt.getLhs() != body.getArgument(1) ||
      index_lt.getRhs() != body.getArgument(3))
    return failure();

  return success();
}

	// Specifies the limit for the number of retries within an
	// index before marking this index as failed. When enabled the number of
	// failures per index is kept in the pod's
	// batch.kubernetes.io/job-index-failure-count annotation. It can only
	// be set when Job's completionMode=Indexed, and the Pod's restart
	// policy is Never. The field is immutable.

		for _, path := range provider.ListedPaths() {
			ret.Insert(path)
		}
	}

	return ret.List()
}

// Index provides a webservice for the http root / listing all known paths.
type Index struct{}

// Install adds the Index webservice to the given mux.
func (i Index) Install(pathProvider ListedPathProvider, mux *mux.PathRecorderMux) {
	handler := IndexLister{StatusCode: http.StatusOK, PathProvider: pathProvider}

                potentialElementSource = indexes: 0..14, line/column: 1/1..1/15, file: test,
                erroneousSource = indexes: 13..14, line/column: 1/14..1/15, file: test
            )
            UnsupportedConstruct(
                languageFeature = StarImport,
                potentialElementSource = indexes: 15..25, line/column: 2/1..2/11, file: test,
                erroneousSource = indexes: 24..25, line/column: 2/10..2/11, file: test

    return delegateCollection().comparator();
  }

  // Override indexOf() and lastIndexOf() to be O(log N) instead of O(N).

  @GwtIncompatible // ImmutableSortedSet.indexOf
  // TODO(cpovirk): consider manual binary search under GWT to preserve O(log N) lookup
  @Override
  public int indexOf(@CheckForNull Object target) {
    int index = delegateCollection().indexOf(target);