LogicalResult ConstantTensorOp::verify() {
  ConstantTensorOp op = *this;
  auto input_type = op.getArg().getType();
  auto output_type = op.getOut().getType();

  if (auto output_tensor_type = output_type.dyn_cast<TFRTensorType>()) {
    return success();
  }

  auto output_tensor_type = output_type.dyn_cast<RankedTensorType>();
  if (!output_tensor_type || !output_tensor_type.hasStaticShape()) {

           << "'hash_seed' attribute is not set or not an array";
  }
  auto output_type = GetResultType(func, 0);
  if (!output_type || !mlir::isa<FloatType>(output_type.getElementType()) ||
      !RankEquals(output_type, 2)) {
    return func.emitError() << "Output should be a 2D float tensor.";
  }
  if (output_type.getDimSize(1) != hash_seed.size()) {
    return func.emitError()

      for (Type& type : llvm::make_range(&state_->types[original_size],
                                         state_->types.end())) {
        Type output_type;
        TF_RETURN_IF_ERROR(AddRef(type, &output_type));
        type = output_type;
      }
    }
  }
  for (auto& it : attrs_) state_->addAttribute(it.first(), it.second);
  *state = state_.get();
  return absl::OkStatus();
}

// This is only valid for trivial reshape ops.
inline DenseElementsAttr GetPermutationFromTrivialReshape(
    ShapedType input_type, ShapedType output_type) {
  ArrayRef<int64_t> in_shape = input_type.getShape();
  ArrayRef<int64_t> out_shape = output_type.getShape();

  // Get the indexes of the non-identity dimensions and the identity dimensions
  // in the input shape.

push: build

# split words on hyphen, access by 1-index
word-hyphen = $(word $2,$(subst -, ,$1))

sub-build-%:
	$(MAKE) OUTPUT_TYPE=docker OS=$(call word-hyphen,$*,1) ARCH=$(call word-hyphen,$*,2) build

all-build: $(addprefix sub-build-,$(ALL_OS_ARCH))

sub-push-image-%:
	$(MAKE) OUTPUT_TYPE=registry OS=$(call word-hyphen,$*,1) ARCH=$(call word-hyphen,$*,2) OSVERSION=$(call word-hyphen,$*,3) REGISTRY=$(PUSH_REGISTRY) push

           << operand0_type;
  }
  for (Type output_type : switchn.getResultTypes()) {
    if (mlir::isa<ControlType>(output_type)) break;

    TensorType output_tensor_type = mlir::dyn_cast<TensorType>(output_type);
    if (!output_tensor_type) {
      return switchn.emitOpError()
             << "expects outputs to have tensor type but got " << output_type;
    }

      !op.getAdjY() ? create_z_x_transpose_op(input_rhs) : input_rhs;

  Type output_type = op.getResult().getType();
  auto no_input = rewriter.create<TFL::NoValueOp>(
      op->getLoc(), rewriter.getNoneType(), rewriter.getUnitAttr());
  auto fc_op = rewriter.create<TFL::FullyConnectedOp>(
      op->getLoc(), ArrayRef<Type>{output_type},
      /*input=*/legalized_lhs, /*filter=*/legalized_rhs, /*bias=*/no_input,

        def namingScheme = createNamingScheme(parentName, binaryType, dimensions)

        expect:
        namingScheme.getOutputDirectory(new File("."), outputType) == new File(".", outputDir)

        where:
        parentName    | binaryType   | dimensions                                 | outputType | outputDir
        "test"        | null         | []                                         | null       | "test"

  DataType input_type(int32_t o) const { return node_->input_type(o); }
  Output input(int32_t i) const;

  int32 num_outputs() const { return node_->num_outputs(); }
  DataType output_type(int32_t o) const { return node_->output_type(o); }
  Output output(int32_t i) const;

  Node* node() const { return node_; }

  uint64 hash(int32_t index) const;

      result.get(),
      "slice_with_slice_input/static_shaped_slice/static_shaped_slice");
  ASSERT_NE(static_shaped_slice, nullptr);
  EXPECT_EQ(static_shaped_slice->output_type(0), DT_FLOAT)
      << "Expected DT_FLOAT, was "
      << DataType_Name(static_shaped_slice->output_type(0));
  EXPECT_THAT(
      static_shaped_slice,
      NodeWith(
          Op("Slice"),
          Inputs(Out(NodeWith(
                     Op("Slice"),