// The upper bits of the smaller than register values is undefined. Take advantage of that.
(AND <t> x:(MOVDconst [m]) n) && t.Size() <= 2 => (ANDconst [int64(int16(m))] n)

// Convert simple bit masks to an equivalent rldic[lr] if possible.
(AND x:(MOVDconst [m]) n) && isPPC64ValidShiftMask(m) => (RLDICL [encodePPC64RotateMask(0,m,64)] n)

  StringRef getArgument() const final {
    // This is the argument used to refer to the pass in
    // the textual format (on the commandline for example).
    return "quant-convert-tpu-model-to-cpu";
  }
  StringRef getDescription() const final {
    return "Convert TPU models to CPU by rewriting TPU related operations.";
  }

  void runOnOperation() override;
};

class RemoveTpuOp : public RewritePattern {
 public:

     * When method return type should be boxed (e.g., kotlin.Int to Ljava/lang/Integer;)
     */
    RETURN_TYPE_BOXED,

    /**
     * Optimal mode to convert the return type of declarations if it's part of signature.
     */
    RETURN_TYPE,

    /**
     * Optimal mode to convert the type of value parameter if it's part of signature.
     */
    VALUE_PARAMETER,
}

                        else -> errorWithAttachment("Can't convert ${value::class} to the Analysis API") {
                            withEntry("value", value) { value.toString() }
                        }
                    },
                    builder.token
                )
            )
            else -> errorWithAttachment("Can't convert ${returnsEffect::class} to the Analysis API")  {

        when:
        fails 'checkDeps'

        then:
        failure.assertHasCause """Conflict found for the following module:
  - org:foo between versions 1.1 and 1.0"""
        failure.assertHasResolutions("Run with :dependencyInsight --configuration conf " +
            "--dependency org:foo to get more insight on how to solve the conflict.",
            STACKTRACE_MESSAGE,
            INFO_DEBUG,
            SCAN,

    // This is the argument used to refer to the pass in the textual format (on
    // the commandline for example).
    return "quant-convert-tf-custom-aggregator-op-to-quant-stats";
  }

  StringRef getDescription() const final {
    // This is a brief description of the pass.
    return "Convert tf.CustomAggregator op to quant.Stats";
  }

  void getDependentDialects(DialectRegistry &registry) const override {

        event.prompt == "question? [yes, no] " // trailing space
    }

    def "accepts valid input"() {
        def event = new YesNoQuestionPromptEvent(123, "question?")

        expect:
        def result = event.convert(input)
        result.response == expected
        result.newPrompt == null

        where:
        input   | expected
        "yes"   | true
        " yes " | true
        "no"    | false

#include "tsl/platform/statusor.h"

#define DEBUG_TYPE "run-tf-graph-optimization"

namespace tensorflow {
namespace {
// Creates a pass to convert MLIR to Graph, run user-specified Graph
// Optimization Passes and convert back to MLIR.
// Constraints: This pass expects that all operations in the MLIR module either
// belong to 'tf' or '_tf' dialect. The output is in '_tf' dialect.
class GraphOptPass

    outConvertedType = converted.getType();
    return converted;
  }
  // Nothing else matched: try to convert a primitive.
  return convertPrimitiveValueAttr(realValue, quantizedElementType, converter,
                                   outConvertedType);
}

/// Convert an attribute from a type based on
/// quantizedElementType.getExpressedType() to one based on
/// quantizedElementType.getStorageType().

#include "tensorflow/compiler/mlir/quantization/tensorflow/python/py_function_lib.h"
#include "tensorflow/python/lib/core/pybind11_lib.h"

namespace py = pybind11;

PYBIND11_MODULE(_pywrap_converter_api, m) {
  m.def(
      "Convert",
      [](py::object model_flags_proto_txt_raw,
         py::object toco_flags_proto_txt_raw, py::object input_contents_txt_raw,
         bool extended_return, py::object debug_info_txt_raw,
         bool enable_mlir_converter,