<< 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"

  }

  for (auto result : llvm::zip(getResultTypes(), getOutputSpecs())) {
    Type outputType = std::get<0>(result);
    Attribute outputSpec = std::get<1>(result);
    if (!isValidQuantizationSpec(outputSpec, outputType)) {
      return emitOpError() << "has incompatible specification " << outputSpec
                           << " and output type " << outputType;
    }
  }
  return success();
}

LogicalResult StatisticsOp::verify() {

  }

  for (auto result : llvm::zip(getResultTypes(), getOutputSpecs())) {
    Type outputType = std::get<0>(result);
    Attribute outputSpec = std::get<1>(result);
    if (!isValidQuantizationSpec(outputSpec, outputType)) {
      return emitOpError() << "has incompatible specification " << outputSpec
                           << " and output type " << outputType;
    }
  }
  return success();
}

LogicalResult StatisticsOp::verify() {

  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"),

  return kTfLiteOk;
}

TfLiteStatus QuantizeModel(ModelT* model, const TensorType& input_type,
                           const TensorType& output_type, bool allow_float,
                           std::string& output_buffer) {
  return QuantizeModel(model, input_type, output_type, allow_float,
                       /*operator_names=*/{}, TensorType_INT8, output_buffer);
}

            consumer.accept(filePropertySpec);
        }
    }

    private static void resolveCompositeOutputFilePropertySpecs(final String ownerDisplayName, final String propertyName, Object unpackedValue, final TreeType outputType, FileCollectionFactory fileCollectionFactory, Consumer<OutputFilePropertySpec> consumer) {
        if (unpackedValue instanceof Map) {
            for (Map.Entry<?, ?> entry : ((Map<?, ?>) unpackedValue).entrySet()) {

  TF_RETURN_IF_ERROR(OutputTypesForNode(node_def, *op_def, &output_dtys));

  mlir::MLIRContext* context = tfr_module_.getContext();
  llvm::SmallVector<mlir::Type, 4> input_tys, output_tys;
  mlir::Builder builder(context);
  for (auto ty : input_dtys) {
    mlir::Type elt_ty;
    TF_RETURN_IF_ERROR(ConvertDataType(ty, builder, &elt_ty));