//   and the preset's configs are ignored.
//   - For `QuantizationSpecs`, the expanded `QuantizationSpec`s will be
//   populated first and user-provided `QuantizationSpec`s, if any, will be
//   appended. This expresses the fact that user-provided specs take precedence.
// * Preset unspecified
//   - No-op.
QuantizationConfig ExpandPresets(const QuantizationConfig& config);

You could do that with `openapi_extra`:

```Python hl_lines="20-37  39-40"
{!../../../docs_src/path_operation_advanced_configuration/tutorial006.py!}
```

   *
   * <p>Historically, {@code Function} instances in this library have implemented this method to
   * recognize certain cases where distinct {@code Function} instances would in fact behave
   * identically. However, as code migrates to {@code java.util.function}, that behavior will
   * disappear. It is best not to depend on it.
   */
  @Override
  boolean equals(@CheckForNull Object object);

	"github.com/stretchr/testify/require"
	"k8s.io/apimachinery/pkg/util/httpstream/wsstream"
)

// fakeHandler implements http.Handler interface
type fakeHandler struct {
	served bool
}

// ServeHTTP stores the fact that this fake handler was called.
func (fh *fakeHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	fh.served = true
}

func TestTranslatingHandler(t *testing.T) {
	tests := map[string]struct {

}

// Defines configurations used to resolve external dependencies
// that the public API depends on.
// TODO: We should be able to derive these dependencies automatically.
//       In fact, our public API should have no external dependencies.
val externalApi = configurations.dependencyScope("externalApi") {
    description = "External dependencies that the public Gradle API depends on"
}

			pass.ReadFile = analysisinternal.MakeReadFile(pass)

			t0 := time.Now()
			act.result, act.err = a.Run(pass)

			if act.err == nil { // resolve URLs on diagnostics.
				for i := range act.diagnostics {
					if url, uerr := analysisflags.ResolveURL(a, act.diagnostics[i]); uerr == nil {
						act.diagnostics[i].URL = url
					} else {
						act.err = uerr // keep the last error
					}
				}
			}
			if false {

     *
     * @since 5.6
     */
    Provider<T> getLocationOnly();

        "shake",
        "grain",
        "root",
        "rain",
        "cover",
        "crib",
        "lunchroom",
        "sort",
        "building",
        "fact",
        "grass",
        "planes",
        "stove",
        "pull",
        "calculator",
        "suggestion",
        "beginner",
        "plough",
        "insurance",
        "hat",

            .map(ClassPathTransformedArtifact::ofTransformedArtifact)
            // We sort based on the original classpath to we keep the original order,
            // we also rely on the fact that for ordered streams `sorted()` method has stable sort.
            .sorted((first, second) -> ordering.compare(first.originalIdentifier, second.originalIdentifier))
            .map(artifact -> artifact.file)

(ADDSconstflags [c] x) && !isARM64addcon(c)  => (ADDSflags x (MOVDconst [c]))

// These rules remove unneeded sign/zero extensions.
// They occur in late lower because they rely on the fact
// that their arguments don't get rewritten to a non-extended opcode instead.

// Boolean-generating instructions (NOTE: NOT all boolean Values) always
// zero upper bit of the register; no need to zero-extend