* **Machine Learning**: normalmente requiere muchas multiplicaciones de "matrices" y "vectores". Piensa en una enorme hoja de cálculo con números y multiplicando todos juntos al mismo tiempo.

	VFWCVTXUFV	X10, V3				// ERROR "expected vector register in vs2 position"
	VFWCVTXFV	X10, V3				// ERROR "expected vector register in vs2 position"
	VFWCVTRTZXUFV	X10, V3				// ERROR "expected vector register in vs2 position"
	VFWCVTRTZXFV	X10, V3				// ERROR "expected vector register in vs2 position"
	VFWCVTFXUV	X10, V3				// ERROR "expected vector register in vs2 position"
	VFWCVTFXV	X10, V3				// ERROR "expected vector register in vs2 position"

	"hash/crc32"
	"internal/obscuretestdata"
	"io"
	"maps"
	"math"
	"os"
	"path"
	"reflect"
	"slices"
	"strconv"
	"strings"
	"testing"
	"time"
)

func TestReader(t *testing.T) {
	vectors := []struct {
		file     string    // Test input file
		obscured bool      // Obscured with obscuretestdata package
		headers  []*Header // Expected output headers

	VLUXEI8V	(X10), V2, V1, V3		// ERROR "invalid vector mask register"
	VSUXEI8V	V3, V2, V1, (X10)		// ERROR "invalid vector mask register"
	VLOXEI8V	(X10), V2, V1, V3		// ERROR "invalid vector mask register"
	VSOXEI8V	V3, V2, V1, (X10)		// ERROR "invalid vector mask register"
	VLSEG2E8V	(X10), V1, V3			// ERROR "invalid vector mask register"
	VLSEG2E8FFV	(X10), V1, V3			// ERROR "invalid vector mask register"

  std::vector<std::string> tensor_id_data;
};

struct TF_ImportGraphDefResults {
  std::vector<TF_Output> return_tensors;
  std::vector<TF_Operation*> return_nodes;
  std::vector<const char*> missing_unused_key_names;
  std::vector<int> missing_unused_key_indexes;

  // Backing memory for missing_unused_key_names values.
  std::vector<std::string> missing_unused_key_names_data;
};

                           const string& op_name) {
  std::vector<int64_t> input_ids(inputs.size());
  std::vector<tensorflow::DataType> input_dtypes(inputs.size());
  for (int i = 0; i < inputs.size(); i++) {
    input_ids[i] = ToId(inputs[i]);
    input_dtypes[i] = inputs[i]->DataType();
  }
  std::vector<TapeTensor> tape_tensors;
  tape_tensors.reserve(outputs.size());
  for (auto t : outputs) {

	// 31.11.15: Vector Integer Merge Instructions
	VMERGEVVM	V1, V2, V0, V3			// d781205c
	VMERGEVXM	X10, V2, V0, V3			// d741255c
	VMERGEVIM	$15, V2, V0, V3			// d7b1275c

	// 31.11.16: Vector Integer Move Instructions
	VMVVV		V2, V3				// d701015e
	VMVVX		X10, V3				// d741055e
	VMVVI		$15, V3				// d7b1075e

	// 31.12.1: Vector Single-Width Saturating Add and Subtract

			ops     fileOps
			wantCnt int64
			wantErr error
		}
		testClose struct { // Close() == wantErr
			wantErr error
		}
		testFnc any // testHeader | testWrite | testReadFrom | testClose
	)

	vectors := []struct {
		file     string // Optional filename of expected output
		obscured bool   // Whether file is obscured
		tests    []testFnc
	}{{
		// The writer test file was produced with this command:

    std::vector<TF_Output> out;
    for (auto op : ops) {
      out.push_back({op, 0});
    }
    return out;
  }

  void Define(int num_opers, const std::vector<TF_Operation*>& opers,
              const std::vector<TF_Operation*>& inputs,
              const std::vector<TF_Operation*>& outputs,
              const std::vector<std::string>& output_names,
              bool expect_failure = false) {

  }

  // Checks the expected result of shape inference for the given `op`.
  void CheckOutputShapes(
      TFE_Op* op,
      const std::vector<absl::optional<std::vector<int64_t>>>& input_shapes_vec,
      const std::vector<TF_Tensor*>& input_tensors,
      const absl::optional<std::vector<int64_t>>& expected_shape) {
    // Create input_shapes.
    TF_ShapeAndTypeList* input_shapes =