assertTrue(DefaultMirrorSelector.matchPattern(getRepo("a"), "a,"));

        assertFalse(DefaultMirrorSelector.matchPattern(getRepo("b"), "a"));
        assertFalse(DefaultMirrorSelector.matchPattern(getRepo("b"), "a,"));
        assertFalse(DefaultMirrorSelector.matchPattern(getRepo("b"), ",a"));
        assertFalse(DefaultMirrorSelector.matchPattern(getRepo("b"), ",a,"));

		ForwardNotMatchingPreflights: wrapperspb.Bool(false),
		AllowOriginStringMatch: []*matcher.StringMatcher{
			{MatchPattern: &matcher.StringMatcher_Exact{Exact: "exact"}},
			{MatchPattern: &matcher.StringMatcher_Prefix{Prefix: "prefix"}},
			{
				MatchPattern: &matcher.StringMatcher_SafeRegex{
					SafeRegex: &matcher.RegexMatcher{
						Regex: "regex",
					},
				},
			},
		},

  if (mlir::isa<FloatType>(element_type)) {
    DenseFPElementsAttr float_attr;
    if (matchPattern(value, m_Constant(&float_attr)) && float_attr.isSplat() &&
        float_attr.getSplatValue<APFloat>().isExactlyValue(raw_value))
      return true;
  } else if (mlir::isa<IntegerType>(element_type)) {
    DenseIntElementsAttr int_attr;
    if (matchPattern(value, m_Constant(&int_attr)) && int_attr.isSplat() &&

      rhs_dilation_attr, feature_group_count_attr;
  if (!(matchPattern(op.getWindowStrides(), m_Constant(&window_strides_attr)) &&
        matchPattern(op.getPadding(), m_Constant(&padding_attr)) &&
        matchPattern(op.getLhsDilation(), m_Constant(&lhs_dilation_attr)) &&
        matchPattern(op.getRhsDilation(), m_Constant(&rhs_dilation_attr)) &&
        matchPattern(op.getFeatureGroupCount(),

    DenseIntElementsAttr indices;
    if (!matchPattern(gather_nd_first.getIndices(), m_Constant(&indices)))
      return failure();
    int i = 0;
    for (const auto &axis_int : indices.getValues<APInt>()) {
      const int64_t axis = axis_int.getSExtValue();
      if (axis != i / 2) return failure();
      ++i;
    }
    if (!matchPattern(gather_nd_second.getIndices(), m_Constant(&indices)))

		}
		if strings.HasPrefix(header, "*") {
			pattern.MatchPattern = &envoy_type_matcher_v3.StringMatcher_Suffix{
				Suffix: strings.TrimPrefix(header, "*"),
			}
		} else if strings.HasSuffix(header, "*") {
			pattern.MatchPattern = &envoy_type_matcher_v3.StringMatcher_Prefix{
				Prefix: strings.TrimSuffix(header, "*"),
			}
		} else {
			pattern.MatchPattern = &envoy_type_matcher_v3.StringMatcher_Exact{
				Exact: header,

                                          DenseElementsAttr perm2_const) {
  SmallVector<int32_t> initial_permutation;
  DenseElementsAttr perm1_const;

  SmallVector<int32_t> new_permutation;
  if (matchPattern(permutation1, m_Constant(&perm1_const))) {
    for (int32_t idx = 0; idx < perm1_const.getNumElements(); ++idx) {
      initial_permutation.push_back(idx);
    }
    for (auto perm : perm2_const.getValues<APInt>()) {

    if (auto rhs = bmm_op.getY(); !matchPattern(rhs, m_Constant(&constant))) {
      // The constant may be preceded by QDQs in models with QDQ format, so we
      // should set it to the real constant.
      auto dq = dyn_cast_or_null<DequantizeOp>(rhs.getDefiningOp());
      if (!dq) return failure();
      auto q = dyn_cast_or_null<QuantizeOp>(dq.getInput().getDefiningOp());
      if (!q || !matchPattern(q.getInput(), m_Constant(&constant))) {

        ArtifactRepository repository = new DefaultArtifactRepository("snapshots.repo", "http://whatever", null);
        String pattern = "external:*, !snapshots.repo";
        assertFalse(DefaultMirrorSelector.matchPattern(repository, pattern));
    }

		if strings.HasPrefix(value, "[") && strings.HasSuffix(value, "]") {
			matchers = append(matchers, &matcherpb.ValueMatcher{
				MatchPattern: &matcherpb.ValueMatcher_ListMatch{
					ListMatch: &matcherpb.ListMatcher{
						MatchPattern: &matcherpb.ListMatcher_OneOf{
							OneOf: &matcherpb.ValueMatcher{
								MatchPattern: &matcherpb.ValueMatcher_StringMatch{
									StringMatch: matcher.StringMatcher(strings.Trim(value, "[]")),
								},