auto permuted = rewriter.create<TransposeOp>(loc, reshaped, permutation);
    auto output_batch = padded_shape_splits[0];
    for (int64_t i = 0; i < block_rank; ++i) {
      output_batch =
          rewriter.create<MulOp>(loc, output_batch, block_shape_splits[i]);
    }
    SmallVector<Value, 4> output_shape_vals{output_batch};
    for (int64_t i = 0; i < block_rank; ++i) {

  // CHECK-DAG: [[OUTPUT_BATCH_PART:%.+]] = "tf.Mul"([[PADDED_SHAPE_SPLITS]]#0, [[BLOCK_SHAPE_SPLITS]]#0)
  // CHECK-DAG: [[OUTPUT_BATCH:%.+]] = "tf.Mul"([[OUTPUT_BATCH_PART]], [[BLOCK_SHAPE_SPLITS]]#1)
  // CHECK-DAG: [[OUTPUT_SHAPE:%.+]] = "tf.ConcatV2"([[OUTPUT_BATCH]], [[OUTER_SHAPE_0]], [[OUTER_SHAPE_1]], [[PADDED_SHAPE_SPLITS]]#3, [[ZERO_I64]])
  // CHECK-DAG: [[RESHAPED:%.+]] = "tf.Reshape"([[PADDED]], [[RESHAPED_SHAPE]])

    auto output_shape = output_type.getShape();

    // output batch = input batch / (block_size * block_size).
    int64_t input_batch = input_shape[0];
    int64_t output_batch = output_shape[0];
    if (static_dims(input_batch, output_batch) &&
        (output_batch * block_size * block_size) != input_batch)
      return op.emitOpError()
             << "requires output batch (dimension 0) to be equal to input "

      Invalid model_path.
      Targets are not specified.
      Invalid output_path.
  """
  if not model_path:
    raise ValueError("Invalid model_path.")

  if not targets:
    raise ValueError("Targets are not specified.")

  if not output_path:
    raise ValueError("Invalid output_path.")

  return GenerateOneFile(cpp::RendererContext::kSource);
}

string CppGenerator::HeaderFileName() const {
  return io::JoinPath(path_config_.output_path, cpp_config_.unit + "_ops.h");
}

string CppGenerator::SourceFileName() const {
  return io::JoinPath(path_config_.output_path, cpp_config_.unit + "_ops.cc");
}

void CppGenerator::WriteHeaderFile() const {
  controller_.WriteFile(HeaderFileName(), HeaderFileContents());
}

      elem.tail = indent_str


def create_xml_file(result_store_dict: ResultDictType,
                    output_path: str,
                    verbose: bool = False):
  """Creates a JUnit-based XML file, with each invocation as a testcase."""
  os.makedirs(os.path.dirname(output_path), exist_ok=True)
  failure_count = 0
  error_count = 0

  date_time = datetime.datetime

  def _create_and_save_vocab_table_lookup_model_tf1(
      self,
      output_path: str,
      tags: Collection[str],
      signature_def_key: str,
  ) -> Tuple[Mapping[str, core.Tensor], Mapping[str, core.Tensor]]:
    """Creates and saves a simple model that uses a vocab table.

    Args:
      output_path: Path to the directory to save the created model.

#define TENSORFLOW_C_EXPERIMENTAL_OPS_GEN_COMMON_PATH_CONFIG_H_

#include "tensorflow/core/platform/types.h"

namespace tensorflow {
namespace generator {

struct PathConfig {
  string output_path;
  std::vector<string> op_names;
  std::vector<string> api_dirs;
  string tf_prefix_dir;
  string tf_root_dir;
  string tf_output_dir;

  explicit PathConfig() = default;

opt<std::string> input_model(llvm::cl::Positional,
                             llvm::cl::desc("<input model path>"),
                             llvm::cl::Required);

// NOLINTNEXTLINE
opt<std::string> output_path("o", llvm::cl::desc("<output path>"),
                             llvm::cl::Required);

// NOLINTNEXTLINE
opt<std::string> export_type("export-type", llvm::cl::desc("<export type>"),

namespace generator {

PathConfig::PathConfig(const string& output_dir, const string& source_dir,
                       const string& api_dir_list,
                       const std::vector<string> op_names)
    : output_path(output_dir), op_names(op_names) {
  api_dirs = str_util::Split(api_dir_list, ",", str_util::SkipEmpty());

  // Decompose the directory components given the output/source directories.
  //