}
  }

  // Nothing to do here.
  if (!permutation_op || transpose_ops.empty()) return;
  SmallVector<int64_t, 4> permutation;
  auto perm_attr = mlir::cast<DenseElementsAttr>(permutation_op.getValue());
  for (const auto& value : perm_attr.getValues<APInt>())
    permutation.push_back(value.getSExtValue());

  // We want to make sure the shape of the operand equals the transposed shape.

    auto perm_type = tensorflow::GetTypeFromTFTensorShape(
        {static_cast<int>(perm.size())}, rewriter.getIntegerType(32));
    auto perm_attr =
        DenseElementsAttr::get(perm_type, llvm::ArrayRef<int>(perm));
    auto perm_op = rewriter.create<TF::ConstOp>(loc, perm_type, perm_attr);

    // Create tensor type for the transpose result.
    auto filter_type = mlir::cast<RankedTensorType>(filter.getType());

    TensorType perm_type = operand_type.cloneWith(
        {static_cast<int64_t>(permutation.size())}, rewriter.getI32Type());
    auto perm_attr = DenseIntElementsAttr::get(perm_type, permutation);
    auto perm = rewriter.create<arith::ConstantOp>(op.getLoc(), perm_attr);
    Value input = op.getOperand();

    return rewriter.create<TFL::TransposeOp>(op.getLoc(), input, perm);
  }

  return true;
}

// Create a dummy zero to be fed locally from the host to the TPUExecute.
Value CreateZeroInput(Location loc, OpBuilder& builder, Attribute zero_attr,
                      DenseIntElementsAttr shape_attr) {
  ConstOp zero = builder.create<ConstOp>(loc, zero_attr);
  zero->setAttr(kICIWeightDistributionMlirBridgeMarker,
                builder.getBoolAttr(true));
  ConstOp shape = builder.create<ConstOp>(loc, shape_attr);

    }
    auto perm_value =
        llvm::dyn_cast<DenseElementsAttr>(perm.getValue()).getValues<int32_t>();
    llvm::SmallVector<int32_t> perm_arr(perm_value.begin(), perm_value.end());

    // Compute inverse of input transpose.
    llvm::SmallVector<int32_t> inverse_perm = InvertPermutation(perm_arr);

    if (tpose_arg.getResult().getType() != op->getResult(0).getType()) {

    private int finalOffset;

    private final PriorityQueue<MyToken> queue;

    private MyToken prevToken;

    private final List<MyToken> synonyms;

    private final CharTermAttribute termAttr = addAttribute(CharTermAttribute.class);

    private final OffsetAttribute offsetAttr = addAttribute(OffsetAttribute.class);

    const int rank = perm.getNumElements();
    auto perm_iter = perm.getValues<APInt>();
    if (rank < 3) return false;
    for (int i = 2; i < rank; i++) {
      if (perm_iter[i] != i - 2) {
        return false;
      }
    }
    return perm_iter[0] == rank - 2 && perm_iter[1] == rank - 1;
  }
};

struct FuseLogSoftmax : public OpRewritePattern<TFL::SubOp> {

      Attribute zero_attr;
      if (element_type.isIntOrFloat())
        zero_attr = rewriter.getZeroAttr(type);
      else if (element_type.isa<TF::StringType>())
        zero_attr = DenseStringElementsAttr::get(type, {""});

      if (!zero_attr) return failure();

      auto zero_const = rewriter.create<TF::ConstOp>(op.getLoc(), zero_attr);

    // as specified by element_dtype.
    RankedTensorType zero_type =
        tensorflow::GetTypeFromTFTensorShape({}, element_dtype);
    auto zero_attr = rewriter.getZeroAttr(zero_type);
    auto zero = rewriter.create<arith::ConstantOp>(loc, zero_type, zero_attr);

    rewriter.replaceOpWithNewOp<TF::FillOp>(op, result_type, list_shape, zero);
    return success();
  }
};

struct ConvertTensorListReserve

    // Note on zero_attr integer type: DynamicUpdateSlice op start_indices are
    // required to have matching types. This rewrite rule creates
    // DynamicUpdateSlice ops where the first "start index" is always i32 and
    // subsequent ones are constructed based on zero_attr. Thus the type
    // for zero_attr needs to be i32 as well.
    auto zero_attr = IntegerAttr::get(rewriter.getIntegerType(32), 0);