if_op.erase();
  return success();
}

LogicalResult ConvertCaseOp(CaseOp case_op) {
  OpBuilder builder(case_op);
  auto case_region = builder.create<TF::CaseRegionOp>(
      case_op.getLoc(), case_op.getResultTypes(), case_op.getBranchIndex(),
      case_op.getIsStateless(), case_op.getBranches().size());
  CopyDeviceAndUnderscoredAttributes(case_op, case_region);

  // only executes ops with no side effects.
  mutable llvm::SmallDenseMap<Operation*, bool> is_pure_function_;
};

bool OpSideEffectCollector::IsCallToPureFunction(Operation* callOp) const {
  auto call = llvm::dyn_cast<CallOpInterface>(callOp);
  if (!call)
    return false;  // not a call
  func::FuncOp func_op = dyn_cast<func::FuncOp>(call.resolveCallable(
      &symbol_table_collection_));
  return IsPureFunction(func_op);

    rewriter.replaceOpWithNewOp<TFR::ConstOp>(bl_op, array_attr);
    return success();
  }
};

quant::QuantizedType getQuantizedElementType(CastOp cast_op) {
  if (!cast_op || !cast_op.getInputElementType()) {
    return {};
  }
  return cast_op.getInputElementType()
      .cast<TypeAttr>()
      .getValue()
      .dyn_cast<quant::QuantizedType>();
}

      auto uses = func.getSymbolUses(module);
      if (!uses) continue;
      for (auto& use : *uses) {
        // Only `mlir::func::CallOp` is supported as this requires knowing how
        // to rewrite arguments and results to a function.
        if (!isa<mlir::func::CallOp>(use.getUser())) continue;
        auto caller_parent_func =
            use.getUser()->getParentOfType<func::FuncOp>();

    }
  });
}

std::vector<quantfork::QuantizeRegionOp> QuantizeContext::GetAllOps() {
  std::vector<quantfork::QuantizeRegionOp> all_ops;
  all_ops.reserve(128);
  func_.walk([&](quantfork::QuantizeRegionOp op) { all_ops.push_back(op); });
  return all_ops;
}

KernelSpecs::Signature QuantizeContext::GetSignature(
    quantfork::QuantizeRegionOp op) {
  KernelSpecs::Signature signature;

					newTLSGatewayTest(t).
						Run(func(t framework.TestContext, from echo.Instance, to echo.Target) {
							callOpt := newTLSGatewayCallOpts(to, host, tc.statusCode, tc.useGateway)
							from.CallOrFail(t, callOpt)
						})
				})
			}
		})
}

// TestMutualTlsOrigination test MUTUAL TLS mode with TLS origination happening at Gateway proxy

      parent_module_symbol_table.insert(cloned_func_op);
    }

    // When the `XlaCallModuleOp`'s callee accepts a platform index argument,
    // remove it. This is because when converted to `CallOp` there will be a
    // mismatch btw. the number of arguments passed and number of parameters
    // accepted (the platform index argument is an extra argument that is not
    // expressed by the operands of XlaCallModuleOp).

    // the op using the builder.
    CPred<"ArgTypesMatchCallee(&*$_builder.getInsertionPoint(), $1, $2)">>;

foreach callOp = [TF_PartitionedCallOp, TF_StatefulPartitionedCallOp] in {
  def : Pat<(callOp:$op $args, FlatSymbolRefAttr:$f,
             $config, $config_proto, $executor_type),
            (CallOp $f, $args),
          [(ArgTypesMatchCallee $op, $args, $f)]>;
}

// to functions).
bool IsAlreadyOutlined(WhileOp while_op) {
  auto just_call = [](Region& region) {
    auto it = region.front().begin();
    if (!isa<func::CallOp>(*it)) return false;
    ++it;
    if (!isa<YieldOp>(*it)) return false;
    return true;
  };
  return just_call(while_op.getBody()) && just_call(while_op.getCond());
}

                                         while_region.getBody()));
    } else if (auto case_op = dyn_cast<CaseOp>(op)) {
      llvm::SmallVector<func::FuncOp, 4> functions;
      case_op.get_branch_functions(functions);
      AnalyzeFunctionalCaseOrIfOp(case_op, functions, backtrack_analysis);
    } else if (auto if_op = dyn_cast<IfOp>(op)) {
      AnalyzeFunctionalCaseOrIfOp(