if (!llvm::hasSingleElement(parent_op)) return failure();

    // Find the then and else branch functions.
    func::FuncOp then_func = op.then_function();
    func::FuncOp else_func = op.else_function();

    // If the If has no uses and its functions are side-effect free, then
    // remove.
    // TODO(jpienaar): Remove once recusive side-effects are supported.
    if (op.use_empty() &&

    EquivalenceTester.of(Equivalence.equals().onResultOf(Functions.toStringFunction()))
        .addEquivalenceGroup(new IntValue(1), new IntValue(1))
        .addEquivalenceGroup(new IntValue(2))
        .test();
  }

  public void testOnResultOf_equals() {
    new EqualsTester()
        .addEqualityGroup(
            Equivalence.identity().onResultOf(Functions.toStringFunction()),

                    val functions = superClassSymbol.getDeclaredMemberScope().getAllSymbols()
                        .filterIsInstance<KaFunctionSymbol>()
                        .toList()
                    if (functions.isNotEmpty()) {
                        appendLine("Substituted callables:")
                        withIndent {
                            for (function in functions) {

final class MainKt$ArticleScreenContent$1$1 {
    // source: 'main.kt'
    enclosing method MainKt$ArticleScreenContent$1.invoke()Lkotlin/jvm/functions/Function0;
    synthetic final field $title: java.lang.String
    inner (anonymous) class MainKt$ArticleScreenContent$1
    inner (anonymous) class MainKt$ArticleScreenContent$1$1
    method <init>(p0: java.lang.String): void
    public synthetic bridge method invoke(): java.lang.Object

# Request Parameters

Here's the reference information for the request parameters.

These are the special functions that you can put in *path operation function* parameters or dependency functions with `Annotated` to get data from the request.

It includes:

* `Query()`
* `Path()`
* `Body()`
* `Cookie()`
* `Header()`
* `Form()`
* `File()`

You can import them all directly from `fastapi`:

```python

  llvm::DenseMap<Operation*, llvm::DenseMap<int, int>> args_to_remap;
  llvm::DenseSet<Operation*> do_not_touch;  // Funcs referenced by non-call ops

  // Find all users of functions that are not through a CallOp. Those
  // are functions we need to leave alone.
  module->walk([&](SymbolUserOpInterface op) {
    if (llvm::isa<CallOpInterface>(op.getOperation())) return;

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package sha3

// This file defines the ShakeHash interface, and provides
// functions for creating SHAKE and cSHAKE instances, as well as utility
// functions for hashing bytes to arbitrary-length output.
//
//
// SHAKE implementation is based on FIPS PUB 202 [1]
// cSHAKE implementations is based on NIST SP 800-185 [2]
//

        @Override
        public void beforeTasks(BuildTreeModelController controller) {
            runAction(controller, clientAction.getProjectsEvaluatedAction(), PhasedActionResult.Phase.PROJECTS_LOADED);
        }

        @Override
        public SerializedPayload fromBuildModel(BuildTreeModelController controller) {
            runAction(controller, clientAction.getBuildFinishedAction(), PhasedActionResult.Phase.BUILD_FINISHED);

limitations under the License.
*/

// Package direct provides functions for marshaling and unmarshaling between arbitrary Go values and
// CBOR data, with behavior that is compatible with that of the CBOR serializer. In particular,
// types that implement cbor.Marshaler and cbor.Unmarshaler should use these functions.
package direct

import (
	"k8s.io/apimachinery/pkg/runtime/serializer/cbor/internal/modes"
)

}

def LiftQuantizableSpotsAsFunctionsPass : Pass<"stablehlo-lift-quantizable-spots-as-functions", "mlir::ModuleOp"> {
  let summary = "Replace quantization candidates with composite functions into the module.";
  let description = [{
    Mark frequent fusible patterns as functions for quantization targets.
    In addition to brining performance benefits by reducing q/dq op overhead in non-full quantization,