continue
		}
		if tag, index, conf := m.Match(desired...); conf != No {
			return tag, index
		}
	}
	tag, index, _ = m.Match()
	return
}

// Matcher is the interface that wraps the Match method.
//
// Match returns the best match for any of the given tags, along with
// a unique index associated with the returned tag and a confidence
// score.
type Matcher interface {
	Match(t ...Tag) (tag Tag, index int, c Confidence)
}

          "match": "*_bn",
          "mapping": {
            "type": "text",
            "analyzer": "empty_analyzer"
          }
        }
      },
      {
        "lang_ca": {
          "match": "*_ca",
          "mapping": {
            "type": "text",
            "analyzer": "catalan_analyzer"
          }
        }
      },
      {
        "lang_ca": {
          "match": "*_ckb-iq",
          "mapping": {

          "match": "*_bn",
          "mapping": {
            "type": "text",
            "analyzer": "empty_analyzer"
          }
        }
      },
      {
        "lang_ca": {
          "match": "*_ca",
          "mapping": {
            "type": "text",
            "analyzer": "catalan_analyzer"
          }
        }
      },
      {
        "lang_ca": {
          "match": "*_ckb-iq",
          "mapping": {

    - path: cluster/gce/manifests/etcd.manifest
      match: etcd_docker_tag|etcd_version
    - path: cluster/gce/upgrade-aliases.sh
      match: ETCD_IMAGE|ETCD_VERSION
    - path: cmd/kubeadm/app/constants/constants.go
      match: DefaultEtcdVersion =
    - path: hack/lib/etcd.sh
      match: ETCD_VERSION=
    - path: staging/src/k8s.io/sample-apiserver/artifacts/example/deployment.yaml
      match: gcr.io/etcd-development/etcd

		}
		template = rest
		if num >= 0 {
			if 2*num+1 < len(match) && match[2*num] >= 0 {
				if bsrc != nil {
					dst = append(dst, bsrc[match[2*num]:match[2*num+1]]...)
				} else {
					dst = append(dst, src[match[2*num]:match[2*num+1]]...)
				}
			}
		} else {
			for i, namei := range re.subexpNames {
				if name == namei && 2*i+1 < len(match) && match[2*i] >= 0 {
					if bsrc != nil {

					},
				},
			},
		}, error: "Envoy filter: filter match has no name to match on"},
		{name: "listener with sub filter match and invalid applyTo", in: &networking.EnvoyFilter{
			ConfigPatches: []*networking.EnvoyFilter_EnvoyConfigObjectPatch{
				{
					ApplyTo: networking.EnvoyFilter_NETWORK_FILTER,
					Match: &networking.EnvoyFilter_EnvoyConfigObjectMatch{

        schema.attribute(other)

        def candidate1 = attributes(usage: "match")
        def candidate2 = attributes(usage: "no match")
        def candidate3 = attributes(other: "match")
        def candidate4 = attributes()
        def candidate5 = attributes(usage: "match")

        def requested = attributes(usage: "match", other: "match")

        expect:

          "match": "*_bn",
          "mapping": {
            "type": "text",
            "analyzer": "empty_analyzer"
          }
        }
      },
      {
        "lang_ca": {
          "match": "*_ca",
          "mapping": {
            "type": "text",
            "analyzer": "catalan_analyzer"
          }
        }
      },
      {
        "lang_ca": {
          "match": "*_ckb-iq",
          "mapping": {

	v_0 := v.Args[0]
	// match: (MOVBUreg x:(Equal _))
	// result: x
	for {
		x := v_0
		if x.Op != OpARM64Equal {
			break
		}
		v.copyOf(x)
		return true
	}
	// match: (MOVBUreg x:(NotEqual _))
	// result: x
	for {
		x := v_0
		if x.Op != OpARM64NotEqual {
			break
		}
		v.copyOf(x)
		return true
	}
	// match: (MOVBUreg x:(LessThan _))
	// result: x

		},
		{
			name: "null header match", route: &networking.HTTPRoute{
				Delegate: &networking.Delegate{
					Name:      "test",
					Namespace: "test",
				},
				Match: []*networking.HTTPMatchRequest{{
					Headers: map[string]*networking.StringMatch{
						"header": nil,
					},
				}},
			}, valid: false,
		},
		{
			name: "prefix header match", route: &networking.HTTPRoute{