py::class_<mlir::Type> Type(m, "Type");

  // Type Sub-classes
  py::class_<mlir::FunctionType, mlir::Type>(m, "FunctionType")
      .def("getResults",
           [](mlir::FunctionType& ft) { return ft.getResults().vec(); });

  py::class_<mlir::FloatType, mlir::Type>(m, "FloatType")
      .def("getBF16", &mlir::FloatType::getBF16)
      .def("getF16", &mlir::FloatType::getF16)
      .def("getF32", &mlir::FloatType::getF32)

  void runOnOperation() override;
};

// Inversely permutate a given vector
static SmallVector<int64_t> InvertPermutationToVector(ArrayRef<int64_t> vec,
                                                      ArrayRef<int64_t> perm) {
  return applyPermutation(vec, invertPermutationVector(perm));
}

static RankedTensorType GetPermutedTensorTypeHelper(RankedTensorType type,

type RatioedGaugeVec interface {
	// NewForLabelValuesSafe makes a new vector member for the given tuple of label values,
	// initialized with the given numerator and denominator.
	// Unlike the usual Vec WithLabelValues method, this is intended to be called only
	// once per vector member (at the start of its lifecycle).
	// The "Safe" part is saying that the returned object will function properly after metric registration

	"encoding/hex"
	"math/big"
	"os"
	"strconv"
	"strings"
	"testing"
)

func TestEMSAPSS(t *testing.T) {
	// Test vector in file pss-int.txt from: ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-1/pkcs-1v2-1-vec.zip
	msg := []byte{
		0x85, 0x9e, 0xef, 0x2f, 0xd7, 0x8a, 0xca, 0x00, 0x30, 0x8b,
		0xdc, 0x47, 0x11, 0x93, 0xbf, 0x55, 0xbf, 0x9d, 0x78, 0xdb,
		0x8f, 0x8a, 0x67, 0x2b, 0x48, 0x46, 0x34, 0xf3, 0xc9, 0xc2,

inline bool IsReshapeEquivalentToTranspose(ShapedType input_type,
                                           ShapedType output_type) {
  std::vector<int64_t> in_shape{input_type.getShape().vec()};
  std::vector<int64_t> out_shape{output_type.getShape().vec()};

  // If the reshape changes the number of dimensions so it cannot be interpreted
  // as a transpose.
  if (in_shape.size() != out_shape.size()) {
    return false;
  }

  builder.setInsertionPointAfter(while_op);
  tensorflow::Tensor default_key_tensor(tensorflow::DT_STRING, {3});
  default_key_tensor.vec<tensorflow::tstring>()(0) = kDefaultShardingValue;
  default_key_tensor.vec<tensorflow::tstring>()(1) = kDefaultShardingValue;
  default_key_tensor.vec<tensorflow::tstring>()(2) = kDefaultShardingValue;
  auto default_state_key = builder.create<TF::ConstOp>(
      while_op.getLoc(),

        << ctx.mutable_output(0)->shape().DebugString();
  }
}

TEST(BitcastOpTest, TestUpcast) {
  Tensor int8_input(DT_UINT8, {8});
  for (int i = 0; i < 8; i++) {
    int8_input.vec<uint8>()(i) = static_cast<uint8>(1);
  }
  TestBitcastOp(&int8_input, DT_UINT64, TensorShape(), error::OK);
}

TEST(BitcastOpTest, TestDowncast) {
  Tensor int64_input(static_cast<uint64>(1));

            << "\nlower_tensor_list_ops: " << pass_config.lower_tensor_list_ops
            << "\ntrim_functions_allowlist: "
            << absl::StrJoin(pass_config.trim_functions_allowlist.vec(), ",")
            << "\nform_clusters: " << pass_config.form_clusters
            << "\nunfold_batch_matmul: " << pass_config.unfold_batch_matmul
            << "\noutline_tf_while: " << pass_config.outline_tf_while

	"VCHLF",
	"VCHLG",
	"VCHLBS",
	"VCHLHS",
	"VCHLFS",
	"VCHLGS",
	"VCLZ",
	"VCLZB",
	"VCLZH",
	"VCLZF",
	"VCLZG",
	"VCTZ",
	"VCTZB",
	"VCTZH",
	"VCTZF",
	"VCTZG",
	"VEC",
	"VECB",
	"VECH",
	"VECF",
	"VECG",
	"VECL",
	"VECLB",
	"VECLH",
	"VECLF",
	"VECLG",
	"VERIM",
	"VERIMB",
	"VERIMH",
	"VERIMF",
	"VERIMG",
	"VERLL",
	"VERLLB",

          [](mlir::func::FuncOp& f) -> mlir::Region& { return f.getBody(); },
          py::return_value_policy::reference)
      .def("getArguments",
           [](mlir::func::FuncOp& f) { return f.getArguments().vec(); })
      .def("getName", [](mlir::func::FuncOp& f) { return f.getName().str(); })
      .def("getType", &mlir::func::FuncOp::getFunctionType);

  py::class_<mlir::func::ReturnOp>(m, "ReturnOp")
      .def("create",