},
				},
			},
			Value: &matcher.ValueMatcher{
				MatchPattern: &matcher.ValueMatcher_ListMatch{
					ListMatch: &matcher.ListMatcher{
						MatchPattern: &matcher.ListMatcher_OneOf{
							OneOf: &matcher.ValueMatcher{
								MatchPattern: &matcher.ValueMatcher_StringMatch{
									StringMatch: &matcher.StringMatcher{
										MatchPattern: &matcher.StringMatcher_SafeRegex{
											SafeRegex: &matcher.RegexMatcher{

        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,"));

			name:   "prefix",
			v:      "-prefix-*",
			prefix: "abc",
			want: &matcher.StringMatcher{
				MatchPattern: &matcher.StringMatcher_Prefix{
					Prefix: "abc-prefix-",
				},
			},
		},
		{
			name:   "suffix-empty-prefix",
			v:      "*-suffix",
			prefix: "",
			want: &matcher.StringMatcher{
				MatchPattern: &matcher.StringMatcher_Suffix{
					Suffix: "-suffix",
				},
			},
		},
		{

		out.Value = &matcher.ValueMatcher{
			MatchPattern: &matcher.ValueMatcher_OrMatch{
				OrMatch: &matcher.OrMatcher{
					ValueMatchers: []*matcher.ValueMatcher{
						{
							MatchPattern: &matcher.ValueMatcher_ListMatch{
								ListMatch: listMatcher,
							},
						},
						value,
					},
				},
			},
		}
	} else {
		out.Value = &matcher.ValueMatcher{
			MatchPattern: &matcher.ValueMatcher_ListMatch{

		return matchers[0]
	}
	return &matcher.ValueMatcher{
		MatchPattern: &matcher.ValueMatcher_OrMatch{
			OrMatch: &matcher.OrMatcher{
				ValueMatchers: matchers,
			},
		},
	}
}

// StringMatcherRegex creates a regex string matcher for regex.
func StringMatcherRegex(regex string) *matcher.StringMatcher {
	return &matcher.StringMatcher{
		MatchPattern: &matcher.StringMatcher_SafeRegex{
			SafeRegex: &matcher.RegexMatcher{

    Location loc = for_op.getLoc();
    APInt lower_bound, upper_bound, step;
    if (!matchPattern(for_op.getLowerBound(), m_ConstantInt(&lower_bound)) ||
        !matchPattern(for_op.getUpperBound(), m_ConstantInt(&upper_bound)) ||
        !matchPattern(for_op.getStep(), m_ConstantInt(&step))) {
      return failure();
    }

			dir, pattern = pattern[:j], pattern[j+1:]
		}
		dir = filepath.Join(cwd, dir)
		if pattern == "" {
			return func(p *Package) bool { return p.Dir == dir }
		}
		matchPath := pkgpattern.MatchPattern(pattern)
		return func(p *Package) bool {
			// Compute relative path to dir and see if it matches the pattern.
			rel, err := filepath.Rel(dir, p.Dir)
			if err != nil {

// TreeCanMatchPattern(pattern)(name) reports whether
// name or children of name can possibly match pattern.
// Pattern is the same limited glob accepted by MatchPattern.
func TreeCanMatchPattern(pattern string) func(name string) bool {
	wildCard := false
	if i := strings.Index(pattern, "..."); i >= 0 {
		wildCard = true
		pattern = pattern[:i]
	}
	return func(name string) bool {

		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() &&