return cmp.Compare(b.bytes, a.bytes)
	})
	specs := tr.Version().Specs()
	w := tabwriter.NewWriter(os.Stdout, 3, 8, 2, ' ', 0)
	fmt.Fprintf(w, "Event\tBytes\t%%\tCount\t%%\n")
	fmt.Fprintf(w, "-\t-\t-\t-\t-\n")
	for i := range stats {
		stat := &stats[i]
		name := ""
		if int(stat.typ) >= len(specs) {
			name = fmt.Sprintf("<unknown (%d)>", stat.typ)
		} else {
			name = specs[stat.typ].Name
		}

def _has_quantization_method(
    quantization_specs: qc.QuantizationSpecs, method: str
) -> bool:
  """Returns whether a given QuantizationSpecs has the given quantization method."""
  for spec in quantization_specs.specs:
    if spec.method.HasField(method):
      return True
  return False


# TODO: b/310594193 - Export API to pip package.
def quantize_saved_model(
    src_saved_model_path: str,

    def 'can run Specs2 tests'() {
        given:
        buildFile << """
            plugins {
                id("scala")
            }

            ${mavenCentralRepository()}

            dependencies {
                implementation 'org.scala-lang:scala-library:2.11.8'
                testImplementation 'org.specs2:specs2_2.11:3.7'

 */
package org.gradle.api.internal.project.taskfactory;

import org.gradle.api.Task;
import org.gradle.api.internal.TaskInternal;
import org.gradle.api.internal.project.ProjectInternal;
import org.gradle.api.specs.Specs;
import org.gradle.internal.instantiation.InstantiationScheme;
import org.gradle.internal.reflect.Instantiator;

import javax.annotation.Nullable;

/**

    }

    private Spec<Boolean> createFilterSpec() {
        return new Spec<Boolean>() {
            public boolean isSatisfiedBy(Boolean element) {
                return element;
            }
        };
    }

        List<String> callInterceptorTypes = new ArrayList<>();
        CallInterceptorSpecs specs = GroovyClassGeneratorUtils.groupRequests(filteredRequests);
        specs.getNamedRequests().forEach(spec -> callInterceptorTypes.add(spec.getFullClassName()));
        specs.getConstructorRequests().forEach(spec -> callInterceptorTypes.add(spec.getFullClassName()));

        return new GenerationResult.CanGenerateResource() {
            @Override

    }

    static <T> void checkModelProperty(T actual, T expected, def spec) {
        if (spec instanceof Closure) {
            def getter = spec as Closure
            assert getter(actual) == getter(expected)
        } else if (spec instanceof List) {
            assert spec.size() == 2
            def getter = spec[0] as Closure
            def checker = spec[1]
            def actualValue = getter(actual)

import org.gradle.api.Action;
import org.gradle.api.specs.Spec;
import org.gradle.api.specs.Specs;

import javax.annotation.Nullable;

public class CollectionFilter<T> implements Spec<Object> {

    private final Class<? extends T> type;
    private final Spec<? super T> spec;

    public CollectionFilter(Class<T> type) {
        this(type, Specs.satisfyAll());
    }

import org.gradle.api.internal.artifacts.configurations.MutationValidator;
import org.gradle.api.internal.notations.ModuleIdentifierNotationConverter;
import org.gradle.api.specs.Spec;
import org.gradle.api.specs.Specs;
import org.gradle.internal.rules.DefaultRuleActionAdapter;
import org.gradle.internal.rules.DefaultRuleActionValidator;
import org.gradle.internal.rules.RuleAction;

package org.gradle.internal

import org.gradle.api.specs.Spec
import spock.lang.Specification

class SpecsTest extends Specification {

    static class A {}
    static class B extends A {}
    static class C extends B {}

    def "isInstance spec is satisfied for all instances extending from the specified type"() {
        when:
        Spec<Object> spec = Specs.isInstance(B)

        then: