sr := io.NewSectionReader(f, h.off, h.length)
	m, err := macho.NewFile(sr)
	if err != nil {
		// Not a valid Mach-O file.
		return nil, nil
	}
	return peekMachoPlatform(m)
}

// peekMachoPlatform returns the first LC_VERSION_MIN_* or LC_BUILD_VERSION
// load command found in the Mach-O file, if any.
func peekMachoPlatform(m *macho.File) (*MachoPlatformLoad, error) {
	for _, cmd := range m.Loads {

		if err != nil {
			return nil, apierrors.NewInternalError(err)
		}

		matcher := h.GetCompiledMatcher(a.filterCompiler)
		matchResult := matcher.Match(ctx, versionedAttr, nil, a.authorizer)

		if matchResult.Error != nil {
			klog.Warningf("Failed evaluating match conditions, failing closed %v: %v", h.GetName(), matchResult.Error)

        failure.assertHasCause("""Could not find any version that matches org:test:[1.0,).
Versions rejected by attribute matching:
  - 1.1:
      - Attribute 'color' didn't match. Requested 'green', was: 'blue'
      - Attribute 'shape' matched. Requested 'circle', was: 'circle'
  - 1.0:
      - Attribute 'color' didn't match. Requested 'green', was: 'red'
      - Attribute 'shape' didn't match. Requested 'circle', was: 'square'""")
    }

    private val excludePackagePatterns = listOf(Pattern.compile(".+\\.internal(\\..+)?"))

    fun isPublicApiPackage(packageName: String) =
        includePackagePatterns.any { it.matcher(packageName).matches() } &&
            !excludePackagePatterns.any { it.matcher(packageName).matches() }

	// Output:
	// true
	// true
	// false
	// false
}

func ExampleMatch() {
	matched, err := regexp.Match(`foo.*`, []byte(`seafood`))
	fmt.Println(matched, err)
	matched, err = regexp.Match(`bar.*`, []byte(`seafood`))
	fmt.Println(matched, err)
	matched, err = regexp.Match(`a(b`, []byte(`seafood`))
	fmt.Println(matched, err)

	// Output:
	// true <nil>
	// false <nil>

Dr. Stefan Schimanski <******@****.***> 1486027168 +0100

        this.comparator = comparator;

        Matcher matcher;
        matcher = FINITE_RANGE.matcher(selector);
        if (matcher.matches()) {
            lowerBound = matcher.group(1);
            lowerInclusive = selector.startsWith(OPEN_INC);
            upperBound = matcher.group(2);
            upperInclusive = selector.endsWith(CLOSE_INC);
        } else {
            matcher = LOWER_INFINITE_RANGE.matcher(selector);

		return false
	}

	match := lMatch.FilterChain
	if match == nil {
		return true
	}
	if match.Name != "" {
		if match.Name != fc.Name {
			return false
		}
	}
	if match.Sni != "" {
		if fc.FilterChainMatch == nil || len(fc.FilterChainMatch.ServerNames) == 0 {
			return false
		}
		sniMatched := false

            });
        }
        String message = String.format("Cannot locate %s that match '%s' as %s", context.getType(), context.getOriginalPath(),
            matcher.formatErrorMessage("task", searchContext));

        throw getProblemsService().getInternalReporter().throwing(spec -> configureProblem(spec, matcher, context)
            .contextualLabel(message)

				if len(batch) < *r.Source.Snowball.Batch {
					continue
				}
				writeFn(batch)
				batch = batch[:0]
			}
			writeFn(batch)
			xioutil.SafeClose(slowCh)
		}()
	} else {
		slowCh = walkCh
	}

	workerSize, err := strconv.Atoi(env.Get("_MINIO_BATCH_REPLICATION_WORKERS", strconv.Itoa(runtime.GOMAXPROCS(0)/2)))
	if err != nil {
		return err
	}