if (map instanceof ImmutableClassToInstanceMap) {
      @SuppressWarnings("rawtypes") // JDT-based J2KT Java frontend does not permit the direct cast
      Map rawMap = map;
      @SuppressWarnings("unchecked") // covariant casts safe (unmodifiable)
      ImmutableClassToInstanceMap<B> cast = (ImmutableClassToInstanceMap<B>) rawMap;
      return cast;
    }
    return new Builder<B>().putAll(map).build();
  }

#include "tensorflow/compiler/tf2xla/tf2xla_defs.h"

namespace mlir {
namespace TF {

// TODO(b/229028654) Use definitions from tf2xla_defs.h directly. We currently
// don't do this to avoid explicit casts (implicit conversion from
// `absl::string_view` to `llvm::StringRef` is not supported until C++17).

// Whether soft placement is allowed. If true, the marked node is eligible for
// outside compilation.

     * Retrieves public methods for a class. In case the class is not
     * public, retrieves methods with same signature as its public methods
     * from public superclasses and interfaces (if they exist). Basically
     * upcasts every method to the nearest acccessible method.
     */
    private static Method[] getAccessibleMethods(Class<?> clazz) {
        Method[] methods = clazz.getMethods();

  pass_manager->addPass(
      mlir::tf_saved_model::CreateOptimizeGlobalTensorsPass());

  if (pass_config.shape_inference) {
    // Add a shape inference pass to optimize away the unnecessary casts.
    pass_manager->addPass(mlir::TF::CreateTFShapeInferencePass());
  }

  // Legalize while early to allow further constant folding.
  // TODO(jpienaar): This may not actually matter as we do canonicalization

                builder.add(Simple.typed(typeArgument));
            }
            return builder.build();
        } else {
            return Collections.emptyList();
        }
    }

    /**
     * Casts this {@code ModelType} object to represent a subclass of the class
     * represented by the specified class object.  Checks that the cast
     * is valid, and throws a {@code ClassCastException} if it is not.  If

      yield_op->getOperands().take_front(num_loop_carried);
  args.reserve(loop_carried_yield_operands.size() + new_args.size());
  if (passthru_extra_args) {
    // Add operands of yield to the return, inserting casts if needed.
    for (auto it : llvm::zip_first(loop_carried_yield_operands, types)) {
      auto value = std::get<0>(it);
      auto type = std::get<1>(it);
      if (value.getType() == type) {

    "tf.Yield"(%1) : (tensor<*xf32>) -> ()
 }) {is_stateless = false} : (tensor<i1>) -> tensor<*xf32>
  func.return %0 : tensor<*xf32>
}

// -----

// Match existing function->Region pattern (with casts) for IfRegion

func.func private @testIf1Then(tensor<*xf32>) -> tensor<*xf32>
func.func private @testIf1Else(tensor<*xf32>) -> tensor<*xf32>
func.func @testIf2Result(%arg0: tensor<i1>, %arg1: tensor<2xf32>) -> tensor<2xf32> {

        super(ASM_LEVEL, methodVisitor);
    }

    public void emit(BytecodeFragment bytecode) {
        bytecode.emit(mv);
    }

    /**
     * Unboxes or casts the value at the top of the stack.
     */
    public void _UNBOX(Type targetType) {
        switch (targetType.getSort()) {
            case Type.BOOLEAN:

#include "tensorflow/core/framework/tensor_shape.h"
#include "tensorflow/core/framework/tensor_shape.pb.h"
#include "tensorflow/core/framework/types.pb.h"
#include "tensorflow/core/lib/core/coding.h"
#include "tensorflow/core/platform/casts.h"

using tensorflow::Status;
using tensorflow::Tensor;
using tensorflow::TensorBuffer;
using tensorflow::errors::FailedPrecondition;
using tensorflow::errors::InvalidArgument;

#ifndef LIBTPU_EXCLUDE_C_API_IMPL

#include "tensorflow/core/framework/tensor_shape.h"
#include "tensorflow/core/framework/types.pb.h"
#include "tensorflow/core/lib/gtl/flatmap.h"
#include "tensorflow/core/lib/hash/hash.h"
#include "tensorflow/core/platform/casts.h"
#include "tensorflow/core/platform/errors.h"
#include "tensorflow/core/platform/logging.h"
#include "tensorflow/core/platform/macros.h"
#include "tensorflow/core/platform/path.h"