case *ParenExpr:
		Walk(v, n.X)

	case *SelectorExpr:
		Walk(v, n.X)
		Walk(v, n.Sel)

	case *IndexExpr:
		Walk(v, n.X)
		Walk(v, n.Index)

	case *IndexListExpr:
		Walk(v, n.X)
		walkList(v, n.Indices)

	case *SliceExpr:
		Walk(v, n.X)
		if n.Low != nil {
			Walk(v, n.Low)
		}
		if n.High != nil {
			Walk(v, n.High)
		}
		if n.Max != nil {
			Walk(v, n.Max)
		}

        int index = attributesSchema.getAttributeDisambiguationPrecedence().indexOf(attribute);
        return index == -1 ? Optional.empty() : Optional.of(index + 1); // return ordinals, not indices
    }

    private ReportCapability convertCapability(Capability capability) {
        return new ReportCapability(capability.getGroup(), capability.getName(), capability.getVersion(), false);
    }

    AtomicDoubleArray aa = new AtomicDoubleArray(0);
    assertEquals(0, aa.length());
    assertThrows(IndexOutOfBoundsException.class, () -> aa.get(0));
  }

  /** get and set for out of bound indices throw IndexOutOfBoundsException */
  public void testIndexing() {
    AtomicDoubleArray aa = new AtomicDoubleArray(SIZE);
    for (int index : new int[] {-1, SIZE}) {

				fmt.Fprintf(b, "\tuse(%s[%s:])\n", pae, cni)
				fmt.Fprintf(b, "\tuse(%s[%s:%s])\n", pae, cni, cni)
			}
			return
		}

		// Float variables cannot be used as indices.
		if c == "" && (i == "fgood" || i == "fbad") {
			return
		}
		// Integral float constant is ok.
		if c == "c" && n == "" && i == "fgood" {
			if pass == 0 {
				fmt.Fprintf(b, "\tuse(%s[%s])\n", pae, cni)

  const MIN_WIDTH = 4;
  const MIN_TEXT_WIDTH = 16;
  const TEXT_MARGIN = 2;
  const FONT_SIZE = 12;
  const MIN_FONT_SIZE = 8;

  // Fields
  let pivots = [];          // Indices of currently selected data.Sources entries.
  let matches = new Set();  // Indices of sources that match search
  let elems = new Map();    // Mapping from source index to display elements
  let displayList = [];     // List of boxes to display.

  // CHECK:  %values, %indices = "tfl.topk_v2"(%arg0, %cst) : (tensor<1x4xf32>, tensor<i32>) -> (tensor<1x4xf32>, tensor<1x4xi32>)
  // CHECK:  return %values, %indices : tensor<1x4xf32>, tensor<1x4xi32>
}

func.func @approx_top_k_with_min_k(%arg0: tensor<1x4xf32>) -> (tensor<1x4xf32>, tensor<1x4xi32>) {

                    scrollId = response.getScrollId();
                }
            } finally {
                SuggestUtil.deleteScrollContext(client, scrollId);
            }
            client.admin().indices().prepareRefresh(index).execute().actionGet(settings.getIndicesTimeout());
        } catch (final Exception e) {
            throw new SuggesterException("Failed to exec delete by query.", e);
        }

// TorchIndexSelect op patterns.
//===----------------------------------------------------------------------===//

def : Pat<(MHLO_TorchIndexSelectOp $params, $indices, $axis, $batch_dims),

      Option<"enable_custom_op_quantization_",
              "enable-custom-op-quantization", "std::string", "",
              "Specifies which pairs of a custom op and indices are quantizable where the indices are separated with a space.">,
  ];
}

def PrepareTFPass : Pass<"tfl-prepare-tf", "mlir::func::FuncOp"> {
  let summary = "Prepare TF for legalization to TensorFlow Lite dialect.";

                             .Union();
      }

      auto indices = dim_metadata.getIndices();
      std::vector<int> vector_indices(indices.size(), 0);
      int max_of_indices = 0;
      for (int j = 0, end = indices.size(); j < end; j++) {
        vector_indices[j] = indices[j];
        if (vector_indices[j] > max_of_indices) {
          max_of_indices = vector_indices[j];