
// Copyright (c) 2020-2024, ARM Limited.
//
//    Licensed under the Apache License, Version 2.0 (the "License");
//    you may not use this file except in compliance with the License.
//    You may obtain a copy of the License at
//
//         http://www.apache.org/licenses/LICENSE-2.0
//
//    Unless required by applicable law or agreed to in writing, software
//    distributed under the License is distributed on an "AS IS" BASIS,
//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//    See the License for the specific language governing permissions and
//    limitations under the License.

#include "tensor.h"
#include "arith_util.h"
#include "array_proxy.h"
#include "half.hpp"

using namespace TosaReference;
using namespace Eigen;
using namespace tosa;

TosaReference::Tensor::Tensor(const std::string tensorName_,
                              const DType serializationDtype_,
                              const std::vector<int> shape_)
    : tensorName(tensorName_)
    , serializationDtype(serializationDtype_)
    , shape(shape_)
    , tensorDtype(ConvertDType(serializationDtype_))
{
    producer = nullptr;
    isValid  = false;
    consumers.clear();
    isSubgraphInput     = false;
    isSubgraphOutput    = false;
    isParentGraphOutput = false;
    isVariable          = false;
}

TosaReference::Tensor::~Tensor()
{}

int TosaReference::Tensor::setIsParentGraphOutput()
{
    isParentGraphOutput = true;
    return 0;
}

int TosaReference::Tensor::setIsSubgraphInput()
{
    isSubgraphInput = true;
    return 0;
}

int TosaReference::Tensor::setIsSubgraphOutput()
{
    isSubgraphOutput = true;
    return 0;
}

int TosaReference::Tensor::setIsVariable()
{
    isVariable = true;
    return 0;
}

int TosaReference::Tensor::setProducer(GraphNode* node)
{
    ASSERT_MSG(node, "Tensor::setProducer: no node passed in");
    ASSERT_MSG(!producer, "Tensor::setProducer: producer node already set, tensor %s", tensorName.c_str());
    producer = node;

    return 0;
}

int TosaReference::Tensor::addConsumer(GraphNode* node)
{
    ASSERT_MSG(node, "Tensor::addConsumer: no node passed in");
    consumers.push_back(node);

    return 0;
}

int TosaReference::Tensor::dumpTensorParams(FILE* out) const
{
    fprintf(out, "Name: %s DType=%s isValid=%d Rank=%d Shape=%s\n", tensorName.c_str(), EnumNameTOSAREFTYPE(getDtype()),
            getIsValid(), getRank(), getShapeAsString().c_str());

    return 0;
}

int TosaReference::Tensor::dumpTensorParams(std::ostream& out) const
{
    out << "Name: " << getName() << " DType=" << EnumNameTOSAREFTYPE(getDtype()) << " isValid=" << getIsValid()
        << " Rank=" << getRank() << " Shape=" << getShapeAsString() << "\n";

    return 0;
}

int TosaReference::Tensor::readFromNpyFile(const char* filename)
{
    uint32_t elements            = getElementCount();
    double* f64databuf           = nullptr;
    float* f32databuf            = nullptr;
    half_float::half* f16databuf = nullptr;
    int32_t* i32databuf          = nullptr;
    int64_t* i64databuf          = nullptr;
    bool* bdatabuf               = nullptr;
    NumpyUtilities::NPError nperror;
    TOSA_REF_TYPE dtype       = getDtype();
    DType serialization_dtype = getSerializationDtype();

    assert(dtype == ConvertDType(serialization_dtype));
    // if dtype is FP64, serialization_dtype must be one of FP32, FP16, BF16
    assert(dtype != TOSA_REF_TYPE_FP64 || serialization_dtype == DType_FP32 || serialization_dtype == DType_FP16 ||
           serialization_dtype == DType_BF16 || serialization_dtype == DType_FP8E4M3 ||
           serialization_dtype == DType_FP8E5M2);

    switch (serialization_dtype)
    {
        case DType_FP32:
        case DType_BF16:
        case DType_FP8E4M3:
        case DType_FP8E5M2:
            f32databuf = (float*)calloc(sizeof(float), elements);
            ASSERT_MEM(f32databuf);

            nperror = NumpyUtilities::readFromNpyFile(filename, elements, f32databuf);
            break;
        case DType_FP16:
            f16databuf = (half_float::half*)calloc(sizeof(half_float::half), elements);
            ASSERT_MEM(f16databuf);

            nperror = NumpyUtilities::readFromNpyFile(filename, elements, f16databuf);
            break;
        case DType_INT32:
        case DType_UINT8:
        case DType_INT4:
        case DType_INT8:
        case DType_INT16:
        case DType_UINT16:
            i32databuf = (int32_t*)calloc(sizeof(int32_t), elements);
            ASSERT_MEM(i32databuf);

            nperror = NumpyUtilities::readFromNpyFile(filename, elements, i32databuf);
            break;
        case DType_INT48:
        case DType_SHAPE:
            i64databuf = (int64_t*)calloc(sizeof(int64_t), elements);
            ASSERT_MEM(i64databuf);

            nperror = NumpyUtilities::readFromNpyFile(filename, elements, i64databuf);
            break;
        case DType_BOOL:
            bdatabuf = (bool*)calloc(sizeof(bool), elements);
            ASSERT_MEM(bdatabuf);

            nperror = NumpyUtilities::readFromNpyFile(filename, elements, bdatabuf);
            break;
        default:
            FATAL_ERROR("unknown tensor type=%s", EnumNameDType(serialization_dtype));
    }

    switch (nperror)
    {
        case NumpyUtilities::NO_ERROR:
            break;
        case NumpyUtilities::FILE_NOT_FOUND:
            FATAL_ERROR("readFromNpyFile: Cannot open file %s", filename);
        case NumpyUtilities::FILE_IO_ERROR:
            FATAL_ERROR("readFromNpyFile: IO error reading file: %s", filename);
        case NumpyUtilities::FILE_TYPE_MISMATCH:
            FATAL_ERROR("readFromNpyFile: Tensor type %s and Numpy file type mismatch for tensor %s filename %s",
                        EnumNameTOSAREFTYPE(getDtype()), getName().c_str(), filename);
        case NumpyUtilities::HEADER_PARSE_ERROR:
            FATAL_ERROR("Numpy header parsing error for file: %s", filename);
        case NumpyUtilities::BUFFER_SIZE_MISMATCH:
            FATAL_ERROR("Buffer size does not match numpy file size for tensor %s filename %s", getName().c_str(),
                        filename);
        default:
            FATAL_ERROR("Unknown error parsing Numpy file: %s", filename);
    }

    switch (dtype)
    {
        case TOSA_REF_TYPE_FP16:
            // Convert from fp16 to fp32 so that fp16 values can be manipulated as float
            f32databuf = (float*)calloc(sizeof(float), elements);
            ASSERT_MEM(f32databuf);
            for (uint32_t i = 0; i < elements; i++)
            {
                f32databuf[i] = half_float::half_cast<float, half_float::half>(f16databuf[i]);
            }
            if (setTensorValueFloat(elements, f32databuf))
            {
                free(f16databuf);
                free(f32databuf);
                return 1;
            }
            break;
        case TOSA_REF_TYPE_BF16:
            for (uint32_t i = 0; i < elements; i++)
            {
                ASSERT_MSG(checkValidBFloat(f32databuf[i]), "Input float value not a valid bfloat16 value.");
            }
            if (setTensorValueFloat(elements, f32databuf))
            {
                free(f32databuf);
                return 1;
            }
            break;
        case TOSA_REF_TYPE_FP8E4M3:
        case TOSA_REF_TYPE_FP8E5M2:
            if (setTensorValueFloat(elements, f32databuf))
            {
                free(f32databuf);
                return 1;
            }
            break;
        case TOSA_REF_TYPE_FP32:
            if (setTensorValueFloat(elements, f32databuf))
            {
                free(f32databuf);
                return 1;
            }
            break;
        case TOSA_REF_TYPE_INT32:
        case TOSA_REF_TYPE_UINT8:
        case TOSA_REF_TYPE_INT4:
        case TOSA_REF_TYPE_INT8:
        case TOSA_REF_TYPE_INT16:
        case TOSA_REF_TYPE_UINT16:
            if (setTensorValueInt32(elements, i32databuf))
            {
                free(i32databuf);
                return 1;
            }
            break;
        case TOSA_REF_TYPE_INT48:
        case TOSA_REF_TYPE_SHAPE:
            if (setTensorValueInt64(elements, i64databuf))
            {
                free(i64databuf);
                return 1;
            }
            break;
        case TOSA_REF_TYPE_BOOL:
            if (setTensorValueBool(elements, bdatabuf))
            {
                free(i32databuf);
                return 1;
            }
            break;
        case TOSA_REF_TYPE_FP64:
            switch (serialization_dtype)
            {
                case DType_FP16:
                    // FP16 -> FP64
                    f64databuf = (double*)calloc(sizeof(double), elements);
                    ASSERT_MEM(f64databuf);
                    for (uint32_t i = 0; i < elements; i++)
                    {
                        f64databuf[i] = half_float::half_cast<double, half_float::half>(f16databuf[i]);
                    }
                    if (setTensorValueDouble(elements, f64databuf))
                    {
                        free(f16databuf);
                        free(f64databuf);
                        return 1;
                    }
                    break;
                case DType_BF16:
                    // BF16 -> FP64
                    f64databuf = (double*)calloc(sizeof(double), elements);
                    ASSERT_MEM(f64databuf);
                    for (uint32_t i = 0; i < elements; i++)
                    {
                        ASSERT_MSG(checkValidBFloat(f32databuf[i]), "Input float value not a valid bfloat16 value.");
                        f64databuf[i] = static_cast<double>(f32databuf[i]);
                    }
                    if (setTensorValueDouble(elements, f64databuf))
                    {
                        free(f32databuf);
                        free(f64databuf);
                        return 1;
                    }
                    break;
                case DType_FP8E4M3:
                case DType_FP8E5M2:
                    f64databuf = (double*)calloc(sizeof(double), elements);
                    ASSERT_MEM(f64databuf);
                    for (uint32_t i = 0; i < elements; i++)
                    {
                        f64databuf[i] = static_cast<double>(f32databuf[i]);
                    }
                    if (setTensorValueDouble(elements, f64databuf))
                    {
                        free(f32databuf);
                        free(f64databuf);
                        return 1;
                    }
                    break;
                case DType_FP32:
                    // FP32 -> FP64
                    f64databuf = (double*)calloc(sizeof(double), elements);
                    ASSERT_MEM(f64databuf);
                    for (uint32_t i = 0; i < elements; i++)
                    {
                        f64databuf[i] = static_cast<double>(f32databuf[i]);
                    }
                    if (setTensorValueDouble(elements, f64databuf))
                    {
                        free(f32databuf);
                        free(f64databuf);
                        return 1;
                    }
                    break;
                default:
                    FATAL_ERROR("unexpected tensor type=%s and original tensor type=%s", EnumNameTOSAREFTYPE(dtype),
                                EnumNameDType(serialization_dtype));
            }
            break;
        default:
            FATAL_ERROR("unsupported tensor type=%s", EnumNameTOSAREFTYPE(dtype));
    }

    setIsValid();

    if (f32databuf)
        free(f32databuf);
    if (f16databuf)
        free(f16databuf);
    if (f64databuf)
        free(f64databuf);
    if (i32databuf)
        free(i32databuf);
    if (i64databuf)
        free(i64databuf);
    if (bdatabuf)
        free(bdatabuf);

    return 0;
}

int TosaReference::Tensor::writeToNpyFile(const char* filename) const
{
    float* f32databuf               = nullptr;
    double* f64databuf              = nullptr;
    half_float::half* f16databuf    = nullptr;
    uint8_t* ui8databuf             = nullptr;
    int8_t* i8databuf               = nullptr;
    int16_t* i16databuf             = nullptr;
    uint16_t* ui16databuf           = nullptr;
    int32_t* i32databuf             = nullptr;
    int64_t* i64databuf             = nullptr;
    bool* bdatabuf                  = nullptr;
    NumpyUtilities::NPError nperror = NumpyUtilities::NO_ERROR;
    uint32_t elements               = getElementCount();
    const TOSA_REF_TYPE dtype       = getDtype();

    switch (dtype)
    {
        case TOSA_REF_TYPE_FP32:
        case TOSA_REF_TYPE_BF16:
        case TOSA_REF_TYPE_FP8E4M3:
        case TOSA_REF_TYPE_FP8E5M2:
            f32databuf = (float*)calloc(sizeof(float), elements);
            ASSERT_MEM(f32databuf);

            if (getTensorValueFloat(elements, f32databuf))
            {
                free(f32databuf);
                return 1;
            }
            nperror = NumpyUtilities::writeToNpyFile(filename, shape, f32databuf);

            free(f32databuf);
            break;
        case TOSA_REF_TYPE_FP16:
            f32databuf = (float*)calloc(sizeof(float), elements);
            ASSERT_MEM(f32databuf);
            f16databuf = (half_float::half*)calloc(sizeof(half_float::half), elements);
            ASSERT_MEM(f16databuf);

            if (getTensorValueFloat(elements, f32databuf))
            {
                free(f32databuf);
                free(f16databuf);
                return 1;
            }
            // Convert fp32 to fp16 so that output file contains valid fp16 data
            for (uint32_t i = 0; i < elements; i++)
            {
                f16databuf[i] = half_float::half_cast<half_float::half, float>(f32databuf[i]);
            }
            nperror = NumpyUtilities::writeToNpyFile(filename, shape, f16databuf);

            free(f32databuf);
            free(f16databuf);
            break;
        case TOSA_REF_TYPE_INT32:
            i32databuf = (int32_t*)calloc(sizeof(int32_t), elements);
            ASSERT_MEM(i32databuf);

            if (getTensorValueInt32(elements, i32databuf))
            {
                free(i32databuf);
                return 1;
            }

            nperror = NumpyUtilities::writeToNpyFile(filename, shape, i32databuf);

            free(i32databuf);
            break;
        case TOSA_REF_TYPE_UINT8:
            ui8databuf = (uint8_t*)calloc(sizeof(uint8_t), elements);
            ASSERT_MEM(ui8databuf);

            if (getTensorValueUInt8(elements, ui8databuf))
            {
                free(ui8databuf);
                return 1;
            }

            nperror = NumpyUtilities::writeToNpyFile(filename, shape, ui8databuf);

            free(ui8databuf);
            break;
        case TOSA_REF_TYPE_INT4:
        case TOSA_REF_TYPE_INT8:
            i8databuf = (int8_t*)calloc(sizeof(int8_t), elements);
            ASSERT_MEM(i8databuf);

            if (getTensorValueInt8(elements, i8databuf))
            {
                free(i8databuf);
                return 1;
            }

            nperror = NumpyUtilities::writeToNpyFile(filename, shape, i8databuf);

            free(i8databuf);
            break;
        case TOSA_REF_TYPE_INT16:
            i16databuf = (int16_t*)calloc(sizeof(int16_t), elements);
            ASSERT_MEM(i16databuf);

            if (getTensorValueInt16(elements, i16databuf))
            {
                free(i16databuf);
                return 1;
            }

            nperror = NumpyUtilities::writeToNpyFile(filename, shape, i16databuf);

            free(i16databuf);
            break;
        case TOSA_REF_TYPE_UINT16:
            ui16databuf = (uint16_t*)calloc(sizeof(uint16_t), elements);
            ASSERT_MEM(ui16databuf);

            if (getTensorValueUInt16(elements, ui16databuf))
            {
                free(ui16databuf);
                return 1;
            }

            nperror = NumpyUtilities::writeToNpyFile(filename, shape, ui16databuf);

            free(ui16databuf);
            break;
        case TOSA_REF_TYPE_INT48:
        case TOSA_REF_TYPE_SHAPE:
            i64databuf = (int64_t*)calloc(sizeof(int64_t), elements);
            ASSERT_MEM(i64databuf);

            if (getTensorValueInt64(elements, i64databuf))
            {
                free(i64databuf);
                return 1;
            }

            nperror = NumpyUtilities::writeToNpyFile(filename, shape, i64databuf);

            free(i64databuf);
            break;
        case TOSA_REF_TYPE_BOOL:
            bdatabuf = (bool*)calloc(sizeof(bool), elements);
            ASSERT_MEM(bdatabuf);

            if (getTensorValueBool(elements, bdatabuf))
            {
                free(bdatabuf);
                return 1;
            }

            nperror = NumpyUtilities::writeToNpyFile(filename, shape, bdatabuf);

            free(bdatabuf);
            break;
        case TOSA_REF_TYPE_FP64:
            // @todo : support FP64 dtype
            f64databuf = (double*)calloc(sizeof(double), elements);
            ASSERT_MEM(f64databuf);

            if (getTensorValueDouble(elements, f64databuf))
            {
                free(f64databuf);
                return 1;
            }
            nperror = NumpyUtilities::writeToNpyFile(filename, shape, f64databuf);

            free(f64databuf);
            break;
        case TOSA_REF_TYPE_UNKNOWN:
            FATAL_ERROR("unsupported tensor type=%s", EnumNameTOSAREFTYPE(getDtype()));
    }

    switch (nperror)
    {
        case NumpyUtilities::NO_ERROR:
            break;
        case NumpyUtilities::FILE_NOT_FOUND:
            FATAL_ERROR("writeToNpyFile: Cannot open output file %s", filename);
        case NumpyUtilities::FILE_IO_ERROR:
            FATAL_ERROR("writeToNpyFile: IO error writing file: %s", filename);
        case NumpyUtilities::FILE_TYPE_MISMATCH:
            FATAL_ERROR("writeToNpyFile: Tensor type and Numpy file type mismatch for tensor %s filename %s",
                        getName().c_str(), filename);
        case NumpyUtilities::HEADER_PARSE_ERROR:
            FATAL_ERROR("Numpy header parsing error for file: %s", filename);
        case NumpyUtilities::BUFFER_SIZE_MISMATCH:
            FATAL_ERROR("Buffer size does not match numpy file size for tensor %s filename %s", getName().c_str(),
                        filename);
        default:
            FATAL_ERROR("Unknown error writing Numpy file: %s", filename);
    }

    return 0;
}

template <class T>
int TosaReference::TensorTemplate<T>::copyValueFrom(TosaReference::Tensor* src)
{
    FATAL_ERROR("TensorTemplate<T>::copyValueFrom should not be called.  "
                "Implement template specialization version.");
    return 0;
}

#define DEF_CTENSOR_COPY_VALUE_FROM(RANK, TYPE)                                                                        \
    template <>                                                                                                        \
    int TosaReference::Tensor##RANK<TYPE>::copyValueFrom(TosaReference::Tensor* src)                                   \
    {                                                                                                                  \
        TosaReference::Tensor##RANK<TYPE>* t = dynamic_cast<Tensor##RANK<TYPE>*>(src);                                 \
        if (!t)                                                                                                        \
        {                                                                                                              \
            WARNING("tensor %s templated class does not match %s", src->getName().c_str(), this->getName().c_str());   \
            return 1;                                                                                                  \
        }                                                                                                              \
                                                                                                                       \
        const uint32_t src_rank       = src->getRank();                                                                \
        const uint32_t dst_rank       = this->getRank();                                                               \
        const TOSA_REF_TYPE src_dtype = src->getDtype();                                                               \
        const TOSA_REF_TYPE dst_dtype = this->getDtype();                                                              \
        bool tensor_match             = true;                                                                          \
                                                                                                                       \
        if ((src_rank != dst_rank) || (src_dtype != dst_dtype))                                                        \
        {                                                                                                              \
            tensor_match = false;                                                                                      \
        }                                                                                                              \
        else                                                                                                           \
        {                                                                                                              \
            for (uint32_t i = 0; i < src_rank; i++)                                                                    \
            {                                                                                                          \
                int src_dim = src->getShape()[i];                                                                      \
                int dst_dim = this->getShape()[i];                                                                     \
                if (src_dim != dst_dim)                                                                                \
                {                                                                                                      \
                    tensor_match = false;                                                                              \
                }                                                                                                      \
            }                                                                                                          \
        }                                                                                                              \
                                                                                                                       \
        if (!tensor_match)                                                                                             \
        {                                                                                                              \
            WARNING("source tensor %s (rank=%u, dtype=%s, shape=%s) doesn't match destination tensor %s (rank=%u, "    \
                    "dtype=%s, shape=%s)",                                                                             \
                    src->getName().c_str(), src_rank, EnumNameTOSAREFTYPE(src_dtype), src->getShapeAsString().c_str(), \
                    this->getName().c_str(), dst_rank, EnumNameTOSAREFTYPE(dst_dtype),                                 \
                    this->getShapeAsString().c_str());                                                                 \
            return 1;                                                                                                  \
        }                                                                                                              \
                                                                                                                       \
        this->getTensor() = t->getTensor();                                                                            \
        return 0;                                                                                                      \
    }

DEF_CTENSOR_COPY_VALUE_FROM(0, float)
DEF_CTENSOR_COPY_VALUE_FROM(1, float)
DEF_CTENSOR_COPY_VALUE_FROM(2, float)
DEF_CTENSOR_COPY_VALUE_FROM(3, float)
DEF_CTENSOR_COPY_VALUE_FROM(4, float)
DEF_CTENSOR_COPY_VALUE_FROM(5, float)
DEF_CTENSOR_COPY_VALUE_FROM(6, float)
DEF_CTENSOR_COPY_VALUE_FROM(0, double)
DEF_CTENSOR_COPY_VALUE_FROM(1, double)
DEF_CTENSOR_COPY_VALUE_FROM(2, double)
DEF_CTENSOR_COPY_VALUE_FROM(3, double)
DEF_CTENSOR_COPY_VALUE_FROM(4, double)
DEF_CTENSOR_COPY_VALUE_FROM(5, double)
DEF_CTENSOR_COPY_VALUE_FROM(6, double)
DEF_CTENSOR_COPY_VALUE_FROM(0, int32_t)
DEF_CTENSOR_COPY_VALUE_FROM(1, int32_t)
DEF_CTENSOR_COPY_VALUE_FROM(2, int32_t)
DEF_CTENSOR_COPY_VALUE_FROM(3, int32_t)
DEF_CTENSOR_COPY_VALUE_FROM(4, int32_t)
DEF_CTENSOR_COPY_VALUE_FROM(5, int32_t)
DEF_CTENSOR_COPY_VALUE_FROM(6, int32_t)
DEF_CTENSOR_COPY_VALUE_FROM(0, int64_t)
DEF_CTENSOR_COPY_VALUE_FROM(1, int64_t)
DEF_CTENSOR_COPY_VALUE_FROM(2, int64_t)
DEF_CTENSOR_COPY_VALUE_FROM(3, int64_t)
DEF_CTENSOR_COPY_VALUE_FROM(4, int64_t)
DEF_CTENSOR_COPY_VALUE_FROM(5, int64_t)
DEF_CTENSOR_COPY_VALUE_FROM(6, int64_t)
DEF_CTENSOR_COPY_VALUE_FROM(0, bool)
DEF_CTENSOR_COPY_VALUE_FROM(1, bool)
DEF_CTENSOR_COPY_VALUE_FROM(2, bool)
DEF_CTENSOR_COPY_VALUE_FROM(3, bool)
DEF_CTENSOR_COPY_VALUE_FROM(4, bool)
DEF_CTENSOR_COPY_VALUE_FROM(5, bool)
DEF_CTENSOR_COPY_VALUE_FROM(6, bool)

#undef DEF_CTENSOR_COPY_VALUE_FROM

int TosaReference::Tensor::readfromVector(const ArrayProxy<double> vals)
{
    uint32_t elements = getElementCount();
    switch (getDtype())
    {
        case TOSA_REF_TYPE_FP64:
            if (vals.size() != elements)
            {
                WARNING("The input size (%ld) doesn't match the number of elements (%d) assigned to the tensor.",
                        vals.size(), elements);
                return -1;
            }

            setTensorValueDouble(elements, vals.data());
            break;
        default:
            WARNING("The input type (float) doesn't match the data type assigned to the tensor (%s).",
                    EnumNameTOSAREFTYPE(getDtype()));
            return -2;
    }
    setIsValid();
    return 0;
}

int TosaReference::Tensor::readfromVector(const ArrayProxy<float> vals)
{
    uint32_t elements = getElementCount();
    switch (getDtype())
    {
        case TOSA_REF_TYPE_FP64:
            if (!g_func_config.precise_mode)
            {
                WARNING("The input type (float) doesn't match the data type assigned to the tensor (%s).",
                        EnumNameTOSAREFTYPE(getDtype()));
                return -2;
            }
            // continue with setting float vals in the tensor
        case TOSA_REF_TYPE_FP16:
        case TOSA_REF_TYPE_FP32:
        case TOSA_REF_TYPE_FP8E4M3:
        case TOSA_REF_TYPE_FP8E5M2:
            if (vals.size() != elements)
            {
                WARNING("The input size (%ld) doesn't match the number of elements (%d) assigned to the tensor.",
                        vals.size(), elements);
                return -1;
            }

            setTensorValueFloat(elements, vals.data());
            break;
        case TOSA_REF_TYPE_BF16:
            if (vals.size() != elements)
            {
                WARNING("The input size (%ld) doesn't match the number of elements (%d) assigned to the tensor.",
                        vals.size(), elements);
                return -1;
            }

            for (auto v : vals)
            {
                ASSERT_MSG(checkValidBFloat(v), "Input float value not a valid bfloat16 value.");
            }

            setTensorValueFloat(elements, vals.data());
            break;
        default:
            WARNING("The input type (float) doesn't match the data type assigned to the tensor (%s).",
                    EnumNameTOSAREFTYPE(getDtype()));
            return -2;
    }
    setIsValid();
    return 0;
}

int TosaReference::Tensor::readfromVector(const ArrayProxy<half_float::half> vals)
{
    uint32_t elements = getElementCount();
    std::vector<float> tensor(elements);

    switch (getDtype())
    {
        case TOSA_REF_TYPE_FP64:
            if (!g_func_config.precise_mode)
            {
                WARNING("The input type (float) doesn't match the data type assigned to the tensor (%s).",
                        EnumNameTOSAREFTYPE(getDtype()));
                return -2;
            }
            // continue with setting float vals in the tensor
        case TOSA_REF_TYPE_FP16:
            if (vals.size() != elements)
            {
                WARNING("The input size (%ld) doesn't match the number of elements (%d) assigned to the tensor.",
                        vals.size(), elements);
                return -1;
            }

            // Convert from fp16 to fp32
            for (uint32_t i = 0; i < elements; i++)
            {
                tensor[i] = half_float::half_cast<float, half_float::half>(vals[i]);
            }

            setTensorValueFloat(elements, tensor.data());
            break;
        default:
            WARNING("The input type doesn't match the data type assigned to the tensor (%s).",
                    EnumNameTOSAREFTYPE(getDtype()));
            return -2;
    }
    setIsValid();
    return 0;
}

int TosaReference::Tensor::readfromVector(const ArrayProxy<int8_t> vals)
{
    uint32_t elements = getElementCount();
    switch (getDtype())
    {
        case TOSA_REF_TYPE_INT8:
        case TOSA_REF_TYPE_UINT8:
            if (vals.size() != elements)
            {
                WARNING("The input size (%ld) doesn't match the number of elements (%d) assigned to the tensor.",
                        vals.size(), elements);
                return -1;
            }

            setTensorValueInt8(elements, vals.data());
            break;
        default:
            WARNING("The input type doesn't match the data type assigned to the tensor (%s).",
                    EnumNameTOSAREFTYPE(getDtype()));
            return -2;
    }
    setIsValid();
    return 0;
}

int TosaReference::Tensor::readfromVector(const ArrayProxy<uint16_t> vals)
{
    uint32_t elements = getElementCount();
    switch (getDtype())
    {
        case TOSA_REF_TYPE_INT16:
        case TOSA_REF_TYPE_UINT16:
            if (vals.size() != elements)
            {
                WARNING("The input size (%ld) doesn't match the number of elements (%d) assigned to the tensor.",
                        vals.size(), elements);
                return -1;
            }

            setTensorValueUInt16(elements, vals.data());
            break;
        default:
            WARNING("The input type doesn't match the data type assigned to the tensor (%s).",
                    EnumNameTOSAREFTYPE(getDtype()));
            return -2;
    }
    setIsValid();
    return 0;
}

int TosaReference::Tensor::readfromVector(const ArrayProxy<int16_t> vals)
{
    uint32_t elements = getElementCount();
    switch (getDtype())
    {
        case TOSA_REF_TYPE_INT16:
        case TOSA_REF_TYPE_UINT16:
            if (vals.size() != elements)
            {
                WARNING("The input size (%ld) doesn't match the number of elements (%d) assigned to the tensor.",
                        vals.size(), elements);
                return -1;
            }

            setTensorValueInt16(elements, vals.data());
            break;
        default:
            WARNING("The input type doesn't match the data type assigned to the tensor (%s).",
                    EnumNameTOSAREFTYPE(getDtype()));
            return -2;
    }
    setIsValid();
    return 0;
}

int TosaReference::Tensor::readfromVector(const ArrayProxy<int32_t> vals)
{
    uint32_t elements = getElementCount();
    switch (getDtype())
    {
        case TOSA_REF_TYPE_INT32:
        case TOSA_REF_TYPE_UINT8:
        case TOSA_REF_TYPE_INT4:
        case TOSA_REF_TYPE_INT8:
        case TOSA_REF_TYPE_INT16:
        case TOSA_REF_TYPE_UINT16:
            if (vals.size() != elements)
            {
                WARNING("The input size (%ld) doesn't match the number of elements (%d) assigned to the tensor.",
                        vals.size(), elements);
                return -1;
            }

            setTensorValueInt32(elements, vals.data());
            break;
        default:
            WARNING("The input type doesn't match the data type assigned to the tensor (%s).",
                    EnumNameTOSAREFTYPE(getDtype()));
            return -2;
    }
    setIsValid();
    return 0;
}

int TosaReference::Tensor::readfromVector(const ArrayProxy<int64_t> vals)
{
    uint32_t elements = getElementCount();
    switch (getDtype())
    {
        case TOSA_REF_TYPE_INT48:
        case TOSA_REF_TYPE_SHAPE:
            if (vals.size() != elements)
            {
                WARNING("The input size (%ld) doesn't match the number of elements (%d) assigned to the tensor.",
                        vals.size(), elements);
                return -1;
            }

            setTensorValueInt64(elements, vals.data());
            break;
        default:
            WARNING("The input type doesn't match the data type assigned to the tensor (%s).",
                    EnumNameTOSAREFTYPE(getDtype()));
            return -2;
    }
    setIsValid();
    return 0;
}

int TosaReference::Tensor::readfromVector(const ArrayProxy<unsigned char> vals)
{
    uint32_t elements = getElementCount();

    switch (getDtype())
    {
        case TOSA_REF_TYPE_BOOL:
            if (vals.size() != elements)
            {
                WARNING("The input size (%ld) doesn't match the number of elements (%d) assigned to the tensor.",
                        vals.size(), elements);
                return -1;
            }

            setTensorValueBool(elements, reinterpret_cast<const bool*>(vals.data()));
            break;
        default:
            WARNING("The input type (bool) doesn't match the data type assigned to the tensor (%s).",
                    EnumNameTOSAREFTYPE(getDtype()));
            return -2;
    }
    setIsValid();
    return 0;
}

int TosaReference::Tensor::writeToVector(ArrayProxy<double> vals)
{
    uint32_t elements = getElementCount();

    switch (getDtype())
    {
        case TOSA_REF_TYPE_FP64:
            if (vals.size() != elements)
            {
                WARNING("The output size (%ld) doesn't match the number of elements (%d) assigned to the tensor.",
                        vals.size(), elements);
                return -1;
            }

            getTensorValueDouble(elements, vals.data());
            break;
        default:
            WARNING("The output type (float) doesn't match the data type assigned to the tensor (%s).",
                    EnumNameTOSAREFTYPE(getDtype()));
            return -2;
    }
    return 0;
}

int TosaReference::Tensor::writeToVector(ArrayProxy<float> vals)
{
    uint32_t elements = getElementCount();

    switch (getDtype())
    {
        case TOSA_REF_TYPE_FP16:
        case TOSA_REF_TYPE_FP32:
            if (vals.size() != elements)
            {
                WARNING("The output size (%ld) doesn't match the number of elements (%d) assigned to the tensor.",
                        vals.size(), elements);
                return -1;
            }

            getTensorValueFloat(elements, vals.data());
            break;
        case TOSA_REF_TYPE_BF16:
            if (vals.size() != elements)
            {
                WARNING("The output size (%ld) doesn't match the number of elements (%d) assigned to the tensor.",
                        vals.size(), elements);
                return -1;
            }

            getTensorValueFloat(elements, vals.data());

            for (auto v : vals)
            {
                ASSERT_MSG(checkValidBFloat(v), "Float value not a valid bfloat16 value.");
            }

            break;
        default:
            WARNING("The output type (float) doesn't match the data type assigned to the tensor (%s).",
                    EnumNameTOSAREFTYPE(getDtype()));
            return -2;
    }
    return 0;
}

int TosaReference::Tensor::writeToVector(ArrayProxy<half_float::half> vals)
{
    uint32_t elements = getElementCount();
    std::vector<float> tensor(elements);

    switch (getDtype())
    {
        case TOSA_REF_TYPE_FP16:
            if (vals.size() != elements)
            {
                WARNING("The output size (%ld) doesn't match the number of elements (%d) assigned to the tensor.",
                        vals.size(), elements);
                return -1;
            }

            getTensorValueFloat(elements, tensor.data());

            // Convert fp32 to fp16
            for (uint32_t i = 0; i < elements; i++)
            {
                vals[i] = half_float::half_cast<half_float::half, float>(tensor[i]);
            }
            break;
        default:
            WARNING("The output type doesn't match the data type assigned to the tensor (%s).",
                    EnumNameTOSAREFTYPE(getDtype()));
            return -2;
    }
    return 0;
}

int TosaReference::Tensor::writeToVector(ArrayProxy<int8_t> vals)
{
    uint32_t elements = getElementCount();
    switch (getDtype())
    {
        case TOSA_REF_TYPE_INT8:
        case TOSA_REF_TYPE_UINT8:
            if (vals.size() != elements)
            {
                WARNING("The output size (%ld) doesn't match the number of elements (%d) assigned to the tensor.",
                        vals.size(), elements);
                return -1;
            }

            getTensorValueInt8(elements, vals.data());
            break;
        default:
            WARNING("The output type doesn't match the data type assigned to the tensor (%s).",
                    EnumNameTOSAREFTYPE(getDtype()));
            return -2;
    }
    return 0;
}

int TosaReference::Tensor::writeToVector(ArrayProxy<uint16_t> vals)
{
    uint32_t elements = getElementCount();

    switch (getDtype())
    {
        case TOSA_REF_TYPE_INT16:
        case TOSA_REF_TYPE_UINT16:
            if (vals.size() != elements)
            {
                WARNING("The output size (%ld) doesn't match the number of elements (%d) assigned to the tensor.",
                        vals.size(), elements);
                return -1;
            }

            getTensorValueUInt16(elements, vals.data());
            break;
        default:
            WARNING("The output type doesn't match the data type assigned to the tensor (%s).",
                    EnumNameTOSAREFTYPE(getDtype()));
            return -2;
    }
    return 0;
}

int TosaReference::Tensor::writeToVector(ArrayProxy<int16_t> vals)
{
    uint32_t elements = getElementCount();

    switch (getDtype())
    {
        case TOSA_REF_TYPE_INT16:
        case TOSA_REF_TYPE_UINT16:
            if (vals.size() != elements)
            {
                WARNING("The output size (%ld) doesn't match the number of elements (%d) assigned to the tensor.",
                        vals.size(), elements);
                return -1;
            }

            getTensorValueInt16(elements, vals.data());
            break;
        default:
            WARNING("The output type doesn't match the data type assigned to the tensor (%s).",
                    EnumNameTOSAREFTYPE(getDtype()));
            return -2;
    }
    return 0;
}

int TosaReference::Tensor::writeToVector(ArrayProxy<int32_t> vals)
{
    uint32_t elements = getElementCount();

    switch (getDtype())
    {
        case TOSA_REF_TYPE_INT32:
        case TOSA_REF_TYPE_UINT8:
        case TOSA_REF_TYPE_INT4:
        case TOSA_REF_TYPE_INT8:
        case TOSA_REF_TYPE_INT16:
        case TOSA_REF_TYPE_UINT16:
            if (vals.size() != elements)
            {
                WARNING("The output size (%ld) doesn't match the number of elements (%d) assigned to the tensor.",
                        vals.size(), elements);
                return -1;
            }

            getTensorValueInt32(elements, vals.data());
            break;
        default:
            WARNING("The output type doesn't match the data type assigned to the tensor (%s).",
                    EnumNameTOSAREFTYPE(getDtype()));
            return -2;
    }
    return 0;
}

int TosaReference::Tensor::writeToVector(ArrayProxy<int64_t> vals)
{
    uint32_t elements = getElementCount();

    switch (getDtype())
    {
        case TOSA_REF_TYPE_INT48:
        case TOSA_REF_TYPE_SHAPE:
            if (vals.size() != elements)
            {
                WARNING("The output size (%ld) doesn't match the number of elements (%d) assigned to the tensor.",
                        vals.size(), elements);
                return -1;
            }

            getTensorValueInt64(elements, vals.data());
            break;
        default:
            WARNING("The output type doesn't match the data type assigned to the tensor (%s).",
                    EnumNameTOSAREFTYPE(getDtype()));
            return -2;
    }
    return 0;
}

int TosaReference::Tensor::writeToVector(ArrayProxy<unsigned char> vals)
{
    uint32_t elements = getElementCount();

    switch (getDtype())
    {
        case TOSA_REF_TYPE_BOOL:
            if (vals.size() != elements)
            {
                WARNING("The output size (%ld) doesn't match the number of elements (%d) assigned to the tensor.",
                        vals.size(), elements);
                return -1;
            }

            getTensorValueBool(elements, reinterpret_cast<bool*>(vals.data()));
            break;
        default:
            WARNING("The output type (bool) doesn't match the data type assigned to the tensor (%s).",
                    EnumNameTOSAREFTYPE(getDtype()));
            return -2;
    }
    return 0;
}

template <class T>
int TosaReference::TensorTemplate<T>::setTensorValueDouble(const size_t buflen, const double* vals)
{
    FATAL_ERROR("TensorTemplate<T>::setTensorValueDouble should not be called.  "
                "Implement template specialization version.");
    return 0;
}

template <>
int TosaReference::Tensor0<double>::setTensorValueDouble(const size_t bufLen, const double* vals)
{
    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    (*tensor)(0) = vals[0];

    return 0;
}

template <>
int TosaReference::Tensor1<double>::setTensorValueDouble(const size_t bufLen, const double* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        (*tensor)(i0) = vals[idx++];
    }

    return 0;
}

template <>
int TosaReference::Tensor2<double>::setTensorValueDouble(const size_t bufLen, const double* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            (*tensor)(i0, i1) = vals[idx++];
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor3<double>::setTensorValueDouble(const size_t bufLen, const double* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                (*tensor)(i0, i1, i2) = vals[idx++];
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor4<double>::setTensorValueDouble(const size_t bufLen, const double* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    (*tensor)(i0, i1, i2, i3) = vals[idx++];
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor5<double>::setTensorValueDouble(const size_t bufLen, const double* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        (*tensor)(i0, i1, i2, i3, i4) = vals[idx++];
                    }
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor6<double>::setTensorValueDouble(const size_t bufLen, const double* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        for (int i5 = 0; i5 < shape[5]; i5++)
                        {
                            (*tensor)(i0, i1, i2, i3, i4, i5) = vals[idx++];
                        }
                    }
                }
            }
        }
    }
    return 0;
}

template <class T>
int TosaReference::TensorTemplate<T>::setTensorValueFloat(const size_t buflen, const float* vals)
{
    FATAL_ERROR("TensorTemplate<T>::setTensorValueFloat should not be called.  "
                "Implement template specialization version.");
    return 0;
}

template <>
int TosaReference::Tensor0<float>::setTensorValueFloat(const size_t bufLen, const float* vals)
{
    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    (*tensor)(0) = vals[0];

    return 0;
}

template <>
int TosaReference::Tensor1<float>::setTensorValueFloat(const size_t bufLen, const float* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        (*tensor)(i0) = vals[idx++];
    }

    return 0;
}

template <>
int TosaReference::Tensor2<float>::setTensorValueFloat(const size_t bufLen, const float* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            (*tensor)(i0, i1) = vals[idx++];
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor3<float>::setTensorValueFloat(const size_t bufLen, const float* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                (*tensor)(i0, i1, i2) = vals[idx++];
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor4<float>::setTensorValueFloat(const size_t bufLen, const float* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    (*tensor)(i0, i1, i2, i3) = vals[idx++];
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor5<float>::setTensorValueFloat(const size_t bufLen, const float* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        (*tensor)(i0, i1, i2, i3, i4) = vals[idx++];
                    }
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor6<float>::setTensorValueFloat(const size_t bufLen, const float* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        for (int i5 = 0; i5 < shape[5]; i5++)
                        {
                            (*tensor)(i0, i1, i2, i3, i4, i5) = vals[idx++];
                        }
                    }
                }
            }
        }
    }
    return 0;
}

template <>
int TosaReference::Tensor0<double>::setTensorValueFloat(const size_t bufLen, const float* vals)
{
    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    (*tensor)(0) = vals[0];

    return 0;
}

template <>
int TosaReference::Tensor1<double>::setTensorValueFloat(const size_t bufLen, const float* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        (*tensor)(i0) = vals[idx++];
    }

    return 0;
}

template <>
int TosaReference::Tensor2<double>::setTensorValueFloat(const size_t bufLen, const float* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            (*tensor)(i0, i1) = vals[idx++];
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor3<double>::setTensorValueFloat(const size_t bufLen, const float* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                (*tensor)(i0, i1, i2) = vals[idx++];
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor4<double>::setTensorValueFloat(const size_t bufLen, const float* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    (*tensor)(i0, i1, i2, i3) = vals[idx++];
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor5<double>::setTensorValueFloat(const size_t bufLen, const float* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        (*tensor)(i0, i1, i2, i3, i4) = vals[idx++];
                    }
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor6<double>::setTensorValueFloat(const size_t bufLen, const float* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        for (int i5 = 0; i5 < shape[5]; i5++)
                        {
                            (*tensor)(i0, i1, i2, i3, i4, i5) = vals[idx++];
                        }
                    }
                }
            }
        }
    }
    return 0;
}

template <class T>
int TosaReference::TensorTemplate<T>::setTensorValueUInt8(const size_t bufLen, const uint8_t* vals)
{
    FATAL_ERROR("TensorTemplate<T>::setTensorValueUInt8 should not be called.  "
                "Implement template specialization version.");
    return 0;
}

template <>
int TosaReference::Tensor0<int32_t>::setTensorValueUInt8(const size_t bufLen, const uint8_t* vals)
{
    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    (*tensor)(0) = static_cast<int32_t>(vals[0]);

    return 0;
}

template <>
int TosaReference::Tensor1<int32_t>::setTensorValueUInt8(const size_t bufLen, const uint8_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        (*tensor)(i0) = static_cast<int32_t>(vals[idx++]);
    }

    return 0;
}

template <>
int TosaReference::Tensor2<int32_t>::setTensorValueUInt8(const size_t bufLen, const uint8_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            (*tensor)(i0, i1) = static_cast<int32_t>(vals[idx++]);
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor3<int32_t>::setTensorValueUInt8(const size_t bufLen, const uint8_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                (*tensor)(i0, i1, i2) = static_cast<int32_t>(vals[idx++]);
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor4<int32_t>::setTensorValueUInt8(const size_t bufLen, const uint8_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    (*tensor)(i0, i1, i2, i3) = static_cast<int32_t>(vals[idx++]);
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor5<int32_t>::setTensorValueUInt8(const size_t bufLen, const uint8_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        (*tensor)(i0, i1, i2, i3, i4) = static_cast<int32_t>(vals[idx++]);
                    }
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor6<int32_t>::setTensorValueUInt8(const size_t bufLen, const uint8_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        for (int i5 = 0; i5 < shape[5]; i5++)
                        {
                            (*tensor)(i0, i1, i2, i3, i4, i5) = static_cast<int32_t>(vals[idx++]);
                        }
                    }
                }
            }
        }
    }
    return 0;
}

template <class T>
int TosaReference::TensorTemplate<T>::setTensorValueInt8(const size_t bufLen, const int8_t* vals)
{
    FATAL_ERROR("TensorTemplate<T>::setTensorValueInt8 should not be called.  "
                "Implement template specialization version.");
    return 0;
}

template <>
int TosaReference::Tensor0<int32_t>::setTensorValueInt8(const size_t bufLen, const int8_t* vals)
{
    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    (*tensor)(0) = static_cast<int32_t>(vals[0]);

    return 0;
}

template <>
int TosaReference::Tensor1<int32_t>::setTensorValueInt8(const size_t bufLen, const int8_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        (*tensor)(i0) = static_cast<int32_t>(vals[idx++]);
    }

    return 0;
}

template <>
int TosaReference::Tensor2<int32_t>::setTensorValueInt8(const size_t bufLen, const int8_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            (*tensor)(i0, i1) = static_cast<int32_t>(vals[idx++]);
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor3<int32_t>::setTensorValueInt8(const size_t bufLen, const int8_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                (*tensor)(i0, i1, i2) = static_cast<int32_t>(vals[idx++]);
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor4<int32_t>::setTensorValueInt8(const size_t bufLen, const int8_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    (*tensor)(i0, i1, i2, i3) = static_cast<int32_t>(vals[idx++]);
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor5<int32_t>::setTensorValueInt8(const size_t bufLen, const int8_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        (*tensor)(i0, i1, i2, i3, i4) = static_cast<int32_t>(vals[idx++]);
                    }
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor6<int32_t>::setTensorValueInt8(const size_t bufLen, const int8_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        for (int i5 = 0; i5 < shape[5]; i5++)
                        {
                            (*tensor)(i0, i1, i2, i3, i4, i5) = static_cast<int32_t>(vals[idx++]);
                        }
                    }
                }
            }
        }
    }
    return 0;
}

template <class T>
int TosaReference::TensorTemplate<T>::setTensorValueUInt16(const size_t bufLen, const uint16_t* vals)
{
    FATAL_ERROR("TensorTemplate<T>::setTensorValueUInt16 should not be called.  "
                "Implement template specialization version.");
    return 0;
}

template <>
int TosaReference::Tensor0<int32_t>::setTensorValueUInt16(const size_t bufLen, const uint16_t* vals)
{
    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    (*tensor)(0) = static_cast<int32_t>(vals[0]);

    return 0;
}

template <>
int TosaReference::Tensor1<int32_t>::setTensorValueUInt16(const size_t bufLen, const uint16_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        (*tensor)(i0) = static_cast<int32_t>(vals[idx++]);
    }

    return 0;
}

template <>
int TosaReference::Tensor2<int32_t>::setTensorValueUInt16(const size_t bufLen, const uint16_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            (*tensor)(i0, i1) = static_cast<int32_t>(vals[idx++]);
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor3<int32_t>::setTensorValueUInt16(const size_t bufLen, const uint16_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                (*tensor)(i0, i1, i2) = static_cast<int32_t>(vals[idx++]);
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor4<int32_t>::setTensorValueUInt16(const size_t bufLen, const uint16_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    (*tensor)(i0, i1, i2, i3) = static_cast<int32_t>(vals[idx++]);
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor5<int32_t>::setTensorValueUInt16(const size_t bufLen, const uint16_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        (*tensor)(i0, i1, i2, i3, i4) = static_cast<int32_t>(vals[idx++]);
                    }
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor6<int32_t>::setTensorValueUInt16(const size_t bufLen, const uint16_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        for (int i5 = 0; i5 < shape[5]; i5++)
                        {
                            (*tensor)(i0, i1, i2, i3, i4, i5) = static_cast<int32_t>(vals[idx++]);
                        }
                    }
                }
            }
        }
    }
    return 0;
}

template <class T>
int TosaReference::TensorTemplate<T>::setTensorValueInt16(const size_t bufLen, const int16_t* vals)
{
    FATAL_ERROR("TensorTemplate<T>::setTensorValueInt16 should not be called.  "
                "Implement template specialization version.");
    return 0;
}

template <>
int TosaReference::Tensor0<int32_t>::setTensorValueInt16(const size_t bufLen, const int16_t* vals)
{
    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    (*tensor)(0) = static_cast<int32_t>(vals[0]);

    return 0;
}

template <>
int TosaReference::Tensor1<int32_t>::setTensorValueInt16(const size_t bufLen, const int16_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        (*tensor)(i0) = static_cast<int32_t>(vals[idx++]);
    }

    return 0;
}

template <>
int TosaReference::Tensor2<int32_t>::setTensorValueInt16(const size_t bufLen, const int16_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            (*tensor)(i0, i1) = static_cast<int32_t>(vals[idx++]);
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor3<int32_t>::setTensorValueInt16(const size_t bufLen, const int16_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                (*tensor)(i0, i1, i2) = static_cast<int32_t>(vals[idx++]);
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor4<int32_t>::setTensorValueInt16(const size_t bufLen, const int16_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    (*tensor)(i0, i1, i2, i3) = static_cast<int32_t>(vals[idx++]);
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor5<int32_t>::setTensorValueInt16(const size_t bufLen, const int16_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        (*tensor)(i0, i1, i2, i3, i4) = static_cast<int32_t>(vals[idx++]);
                    }
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor6<int32_t>::setTensorValueInt16(const size_t bufLen, const int16_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        for (int i5 = 0; i5 < shape[5]; i5++)
                        {
                            (*tensor)(i0, i1, i2, i3, i4, i5) = static_cast<int32_t>(vals[idx++]);
                        }
                    }
                }
            }
        }
    }
    return 0;
}

template <class T>
int TosaReference::TensorTemplate<T>::setTensorValueInt32(const size_t bufLen, const int32_t* vals)
{
    FATAL_ERROR("TensorTemplate<T>::setTensorValueInt32 should not be called.  "
                "Implement template specialization version.");
    return 0;
}

template <>
int TosaReference::Tensor0<int32_t>::setTensorValueInt32(const size_t bufLen, const int32_t* vals)
{
    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    (*tensor)(0) = vals[0];

    return 0;
}

template <>
int TosaReference::Tensor1<int32_t>::setTensorValueInt32(const size_t bufLen, const int32_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        (*tensor)(i0) = vals[idx++];
    }

    return 0;
}

template <>
int TosaReference::Tensor2<int32_t>::setTensorValueInt32(const size_t bufLen, const int32_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            (*tensor)(i0, i1) = vals[idx++];
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor3<int32_t>::setTensorValueInt32(const size_t bufLen, const int32_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                (*tensor)(i0, i1, i2) = vals[idx++];
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor4<int32_t>::setTensorValueInt32(const size_t bufLen, const int32_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    (*tensor)(i0, i1, i2, i3) = vals[idx++];
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor5<int32_t>::setTensorValueInt32(const size_t bufLen, const int32_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        (*tensor)(i0, i1, i2, i3, i4) = vals[idx++];
                    }
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor6<int32_t>::setTensorValueInt32(const size_t bufLen, const int32_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        for (int i5 = 0; i5 < shape[5]; i5++)
                        {
                            (*tensor)(i0, i1, i2, i3, i4, i5) = vals[idx++];
                        }
                    }
                }
            }
        }
    }
    return 0;
}

template <class T>
int TosaReference::TensorTemplate<T>::setTensorValueInt64(const size_t bufLen, const int64_t* vals)
{
    FATAL_ERROR("TensorTemplate<T>::setTensorValueInt64 should not be called.  "
                "Implement template specialization version.");
    return 0;
}

template <>
int TosaReference::Tensor0<int64_t>::setTensorValueInt64(const size_t bufLen, const int64_t* vals)
{
    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    (*tensor)(0) = vals[0];

    return 0;
}

template <>
int TosaReference::Tensor1<int64_t>::setTensorValueInt64(const size_t bufLen, const int64_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        (*tensor)(i0) = vals[idx++];
    }

    return 0;
}

template <>
int TosaReference::Tensor2<int64_t>::setTensorValueInt64(const size_t bufLen, const int64_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            (*tensor)(i0, i1) = vals[idx++];
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor3<int64_t>::setTensorValueInt64(const size_t bufLen, const int64_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                (*tensor)(i0, i1, i2) = vals[idx++];
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor4<int64_t>::setTensorValueInt64(const size_t bufLen, const int64_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    (*tensor)(i0, i1, i2, i3) = vals[idx++];
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor5<int64_t>::setTensorValueInt64(const size_t bufLen, const int64_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        (*tensor)(i0, i1, i2, i3, i4) = vals[idx++];
                    }
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor6<int64_t>::setTensorValueInt64(const size_t bufLen, const int64_t* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        for (int i5 = 0; i5 < shape[5]; i5++)
                        {
                            (*tensor)(i0, i1, i2, i3, i4, i5) = vals[idx++];
                        }
                    }
                }
            }
        }
    }
    return 0;
}

template <class T>
int TosaReference::TensorTemplate<T>::setTensorValueBool(const size_t buflen, const bool* vals)
{
    FATAL_ERROR("TensorTemplate<T>::setTensorValueBool should not be called.  "
                "Implement template specialization version.");
    return 0;
}

template <>
int TosaReference::Tensor0<bool>::setTensorValueBool(const size_t bufLen, const bool* vals)
{
    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    (*tensor)(0) = vals[0];

    return 0;
}

template <>
int TosaReference::Tensor1<bool>::setTensorValueBool(const size_t bufLen, const bool* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        (*tensor)(i0) = vals[idx++];
    }

    return 0;
}

template <>
int TosaReference::Tensor2<bool>::setTensorValueBool(const size_t bufLen, const bool* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            (*tensor)(i0, i1) = vals[idx++];
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor3<bool>::setTensorValueBool(const size_t bufLen, const bool* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                (*tensor)(i0, i1, i2) = vals[idx++];
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor4<bool>::setTensorValueBool(const size_t bufLen, const bool* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    (*tensor)(i0, i1, i2, i3) = vals[idx++];
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor5<bool>::setTensorValueBool(const size_t bufLen, const bool* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        (*tensor)(i0, i1, i2, i3, i4) = vals[idx++];
                    }
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor6<bool>::setTensorValueBool(const size_t bufLen, const bool* vals)
{
    uint32_t idx = 0;

    ASSERT_MSG(bufLen == getElementCount(), "Total elements must match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        for (int i5 = 0; i5 < shape[5]; i5++)
                        {
                            (*tensor)(i0, i1, i2, i3, i4, i5) = vals[idx++];
                        }
                    }
                }
            }
        }
    }
    return 0;
}

template <class T>
int TosaReference::TensorTemplate<T>::getTensorValueDouble(const size_t bufLen, double* vals) const
{
    FATAL_ERROR("TensorTemplate<T>::getTensorValueDouble should not be called.  "
                "Implement template specialization version.");
    return 0;
}

template <>
int TosaReference::Tensor0<double>::getTensorValueDouble(const size_t bufLen, double* vals) const
{
    int totalVals = 1;

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    vals[0] = (*tensor)(0);

    return 0;
}

template <>
int TosaReference::Tensor1<double>::getTensorValueDouble(const size_t bufLen, double* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        vals[idx++] = (*tensor)(i0);
    }

    return 0;
}

template <>
int TosaReference::Tensor2<double>::getTensorValueDouble(const size_t bufLen, double* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            vals[idx++] = (*tensor)(i0, i1);
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor3<double>::getTensorValueDouble(const size_t bufLen, double* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                vals[idx++] = (*tensor)(i0, i1, i2);
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor4<double>::getTensorValueDouble(const size_t bufLen, double* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    vals[idx++] = (*tensor)(i0, i1, i2, i3);
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor5<double>::getTensorValueDouble(const size_t bufLen, double* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        vals[idx++] = (*tensor)(i0, i1, i2, i3, i4);
                    }
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor6<double>::getTensorValueDouble(const size_t bufLen, double* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        for (int i5 = 0; i5 < shape[5]; i5++)
                        {
                            vals[idx++] = (*tensor)(i0, i1, i2, i3, i4, i5);
                        }
                    }
                }
            }
        }
    }
    return 0;
}

template <class T>
int TosaReference::TensorTemplate<T>::getTensorValueFloat(const size_t bufLen, float* vals) const
{
    FATAL_ERROR("TensorTemplate<T>::getTensorValueFloat should not be called.  "
                "Implement template specialization version.");
    return 0;
}

template <>
int TosaReference::Tensor0<float>::getTensorValueFloat(const size_t bufLen, float* vals) const
{
    int totalVals = 1;

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    vals[0] = (*tensor)(0);

    return 0;
}

template <>
int TosaReference::Tensor1<float>::getTensorValueFloat(const size_t bufLen, float* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        vals[idx++] = (*tensor)(i0);
    }

    return 0;
}

template <>
int TosaReference::Tensor2<float>::getTensorValueFloat(const size_t bufLen, float* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            vals[idx++] = (*tensor)(i0, i1);
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor3<float>::getTensorValueFloat(const size_t bufLen, float* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                vals[idx++] = (*tensor)(i0, i1, i2);
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor4<float>::getTensorValueFloat(const size_t bufLen, float* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    vals[idx++] = (*tensor)(i0, i1, i2, i3);
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor5<float>::getTensorValueFloat(const size_t bufLen, float* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        vals[idx++] = (*tensor)(i0, i1, i2, i3, i4);
                    }
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor6<float>::getTensorValueFloat(const size_t bufLen, float* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        for (int i5 = 0; i5 < shape[5]; i5++)
                        {
                            vals[idx++] = (*tensor)(i0, i1, i2, i3, i4, i5);
                        }
                    }
                }
            }
        }
    }
    return 0;
}

template <class T>
int TosaReference::TensorTemplate<T>::getTensorValueUInt8(const size_t bufLen, uint8_t* vals) const
{
    std::cout << "T is: " << typeid(T).name() << std::endl;
    FATAL_ERROR("TensorTemplate<T>::getTensorValueUInt8 should not be called.  "
                "Implement template specialization version.");
    return 0;
}

template <>
int TosaReference::Tensor0<int32_t>::getTensorValueUInt8(const size_t bufLen, uint8_t* vals) const
{
    int totalVals = 1;

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    vals[0] = (*tensor)(0);

    return 0;
}

template <>
int TosaReference::Tensor1<int32_t>::getTensorValueUInt8(const size_t bufLen, uint8_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        vals[idx++] = (*tensor)(i0);
    }

    return 0;
}

template <>
int TosaReference::Tensor2<int32_t>::getTensorValueUInt8(const size_t bufLen, uint8_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            vals[idx++] = (*tensor)(i0, i1);
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor3<int32_t>::getTensorValueUInt8(const size_t bufLen, uint8_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                vals[idx++] = (*tensor)(i0, i1, i2);
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor4<int32_t>::getTensorValueUInt8(const size_t bufLen, uint8_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    vals[idx++] = (*tensor)(i0, i1, i2, i3);
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor5<int32_t>::getTensorValueUInt8(const size_t bufLen, uint8_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        vals[idx++] = (*tensor)(i0, i1, i2, i3, i4);
                    }
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor6<int32_t>::getTensorValueUInt8(const size_t bufLen, uint8_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        for (int i5 = 0; i5 < shape[5]; i5++)
                        {
                            vals[idx++] = (*tensor)(i0, i1, i2, i3, i4, i5);
                        }
                    }
                }
            }
        }
    }
    return 0;
}

template <class T>
int TosaReference::TensorTemplate<T>::getTensorValueInt8(const size_t bufLen, int8_t* vals) const
{
    std::cout << "T is: " << typeid(T).name() << std::endl;
    FATAL_ERROR("TensorTemplate<T>::getTensorValueInt8 should not be called.  "
                "Implement template specialization version.");
    return 0;
}

template <>
int TosaReference::Tensor0<int32_t>::getTensorValueInt8(const size_t bufLen, int8_t* vals) const
{
    int totalVals = 1;

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    vals[0] = (*tensor)(0);

    return 0;
}

template <>
int TosaReference::Tensor1<int32_t>::getTensorValueInt8(const size_t bufLen, int8_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        vals[idx++] = (*tensor)(i0);
    }

    return 0;
}

template <>
int TosaReference::Tensor2<int32_t>::getTensorValueInt8(const size_t bufLen, int8_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            vals[idx++] = (*tensor)(i0, i1);
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor3<int32_t>::getTensorValueInt8(const size_t bufLen, int8_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                vals[idx++] = (*tensor)(i0, i1, i2);
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor4<int32_t>::getTensorValueInt8(const size_t bufLen, int8_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    vals[idx++] = (*tensor)(i0, i1, i2, i3);
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor5<int32_t>::getTensorValueInt8(const size_t bufLen, int8_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        vals[idx++] = (*tensor)(i0, i1, i2, i3, i4);
                    }
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor6<int32_t>::getTensorValueInt8(const size_t bufLen, int8_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        for (int i5 = 0; i5 < shape[5]; i5++)
                        {
                            vals[idx++] = (*tensor)(i0, i1, i2, i3, i4, i5);
                        }
                    }
                }
            }
        }
    }
    return 0;
}

template <class T>
int TosaReference::TensorTemplate<T>::getTensorValueUInt16(const size_t bufLen, uint16_t* vals) const
{
    FATAL_ERROR("TensorTemplate<T>::getTensorValueUInt16 should not be called.  "
                "Implement template specialization version.");
    return 0;
}

template <>
int TosaReference::Tensor0<int32_t>::getTensorValueUInt16(const size_t bufLen, uint16_t* vals) const
{
    int totalVals = 1;

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    vals[0] = (*tensor)(0);

    return 0;
}

template <>
int TosaReference::Tensor1<int32_t>::getTensorValueUInt16(const size_t bufLen, uint16_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        vals[idx++] = (*tensor)(i0);
    }

    return 0;
}

template <>
int TosaReference::Tensor2<int32_t>::getTensorValueUInt16(const size_t bufLen, uint16_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            vals[idx++] = (*tensor)(i0, i1);
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor3<int32_t>::getTensorValueUInt16(const size_t bufLen, uint16_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                vals[idx++] = (*tensor)(i0, i1, i2);
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor4<int32_t>::getTensorValueUInt16(const size_t bufLen, uint16_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    vals[idx++] = (*tensor)(i0, i1, i2, i3);
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor5<int32_t>::getTensorValueUInt16(const size_t bufLen, uint16_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        vals[idx++] = (*tensor)(i0, i1, i2, i3, i4);
                    }
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor6<int32_t>::getTensorValueUInt16(const size_t bufLen, uint16_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        for (int i5 = 0; i5 < shape[5]; i5++)
                        {
                            vals[idx++] = (*tensor)(i0, i1, i2, i3, i4, i5);
                        }
                    }
                }
            }
        }
    }
    return 0;
}

template <class T>
int TosaReference::TensorTemplate<T>::getTensorValueInt16(const size_t bufLen, int16_t* vals) const
{
    FATAL_ERROR("TensorTemplate<T>::getTensorValueInt16 should not be called.  "
                "Implement template specialization version.");
    return 0;
}

template <>
int TosaReference::Tensor0<int32_t>::getTensorValueInt16(const size_t bufLen, int16_t* vals) const
{
    int totalVals = 1;

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    vals[0] = (*tensor)(0);

    return 0;
}

template <>
int TosaReference::Tensor1<int32_t>::getTensorValueInt16(const size_t bufLen, int16_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        vals[idx++] = (*tensor)(i0);
    }

    return 0;
}

template <>
int TosaReference::Tensor2<int32_t>::getTensorValueInt16(const size_t bufLen, int16_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            vals[idx++] = (*tensor)(i0, i1);
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor3<int32_t>::getTensorValueInt16(const size_t bufLen, int16_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                vals[idx++] = (*tensor)(i0, i1, i2);
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor4<int32_t>::getTensorValueInt16(const size_t bufLen, int16_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    vals[idx++] = (*tensor)(i0, i1, i2, i3);
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor5<int32_t>::getTensorValueInt16(const size_t bufLen, int16_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        vals[idx++] = (*tensor)(i0, i1, i2, i3, i4);
                    }
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor6<int32_t>::getTensorValueInt16(const size_t bufLen, int16_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        for (int i5 = 0; i5 < shape[5]; i5++)
                        {
                            vals[idx++] = (*tensor)(i0, i1, i2, i3, i4, i5);
                        }
                    }
                }
            }
        }
    }
    return 0;
}

template <class T>
int TosaReference::TensorTemplate<T>::getTensorValueInt32(const size_t bufLen, int32_t* vals) const
{
    FATAL_ERROR("TensorTemplate<T>::getTensorValueInt32 should not be called.  "
                "Implement template specialization version.");
    return 0;
}

template <>
int TosaReference::Tensor0<int32_t>::getTensorValueInt32(const size_t bufLen, int32_t* vals) const
{
    int totalVals = 1;

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    vals[0] = (*tensor)(0);

    return 0;
}

template <>
int TosaReference::Tensor1<int32_t>::getTensorValueInt32(const size_t bufLen, int32_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        vals[idx++] = (*tensor)(i0);
    }

    return 0;
}

template <>
int TosaReference::Tensor2<int32_t>::getTensorValueInt32(const size_t bufLen, int32_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            vals[idx++] = (*tensor)(i0, i1);
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor3<int32_t>::getTensorValueInt32(const size_t bufLen, int32_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                vals[idx++] = (*tensor)(i0, i1, i2);
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor4<int32_t>::getTensorValueInt32(const size_t bufLen, int32_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    vals[idx++] = (*tensor)(i0, i1, i2, i3);
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor5<int32_t>::getTensorValueInt32(const size_t bufLen, int32_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        vals[idx++] = (*tensor)(i0, i1, i2, i3, i4);
                    }
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor6<int32_t>::getTensorValueInt32(const size_t bufLen, int32_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        for (int i5 = 0; i5 < shape[5]; i5++)
                        {
                            vals[idx++] = (*tensor)(i0, i1, i2, i3, i4, i5);
                        }
                    }
                }
            }
        }
    }
    return 0;
}

template <class T>
int TosaReference::TensorTemplate<T>::getTensorValueInt64(const size_t bufLen, int64_t* vals) const
{
    FATAL_ERROR("TensorTemplate<T>::getTensorValueInt64 should not be called.  "
                "Implement template specialization version.");
    return 0;
}

template <>
int TosaReference::Tensor0<int64_t>::getTensorValueInt64(const size_t bufLen, int64_t* vals) const
{
    int totalVals = 1;

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    vals[0] = (*tensor)(0);

    return 0;
}

template <>
int TosaReference::Tensor1<int64_t>::getTensorValueInt64(const size_t bufLen, int64_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        vals[idx++] = (*tensor)(i0);
    }

    return 0;
}

template <>
int TosaReference::Tensor2<int64_t>::getTensorValueInt64(const size_t bufLen, int64_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            vals[idx++] = (*tensor)(i0, i1);
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor3<int64_t>::getTensorValueInt64(const size_t bufLen, int64_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                vals[idx++] = (*tensor)(i0, i1, i2);
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor4<int64_t>::getTensorValueInt64(const size_t bufLen, int64_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    vals[idx++] = (*tensor)(i0, i1, i2, i3);
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor5<int64_t>::getTensorValueInt64(const size_t bufLen, int64_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        vals[idx++] = (*tensor)(i0, i1, i2, i3, i4);
                    }
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor6<int64_t>::getTensorValueInt64(const size_t bufLen, int64_t* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        for (int i5 = 0; i5 < shape[5]; i5++)
                        {
                            vals[idx++] = (*tensor)(i0, i1, i2, i3, i4, i5);
                        }
                    }
                }
            }
        }
    }
    return 0;
}

template <class T>
int TosaReference::TensorTemplate<T>::getTensorValueBool(const size_t bufLen, bool* vals) const
{
    FATAL_ERROR("TensorTemplate<T>::getTensorValueBool should not be called.  "
                "Implement template specialization version.");
    return 0;
}

template <>
int TosaReference::Tensor0<bool>::getTensorValueBool(const size_t bufLen, bool* vals) const
{
    int totalVals = 1;

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    vals[0] = (*tensor)(0);

    return 0;
}

template <>
int TosaReference::Tensor1<bool>::getTensorValueBool(const size_t bufLen, bool* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        vals[idx++] = (*tensor)(i0);
    }

    return 0;
}

template <>
int TosaReference::Tensor2<bool>::getTensorValueBool(const size_t bufLen, bool* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            vals[idx++] = (*tensor)(i0, i1);
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor3<bool>::getTensorValueBool(const size_t bufLen, bool* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                vals[idx++] = (*tensor)(i0, i1, i2);
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor4<bool>::getTensorValueBool(const size_t bufLen, bool* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    vals[idx++] = (*tensor)(i0, i1, i2, i3);
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor5<bool>::getTensorValueBool(const size_t bufLen, bool* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        vals[idx++] = (*tensor)(i0, i1, i2, i3, i4);
                    }
                }
            }
        }
    }

    return 0;
}

template <>
int TosaReference::Tensor6<bool>::getTensorValueBool(const size_t bufLen, bool* vals) const
{
    uint32_t idx  = 0;
    int totalVals = 1;

    for (size_t i = 0; i < shape.size(); i++)
    {
        totalVals *= shape[i];
    }

    ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match");

    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        for (int i5 = 0; i5 < shape[5]; i5++)
                        {
                            vals[idx++] = (*tensor)(i0, i1, i2, i3, i4, i5);
                        }
                    }
                }
            }
        }
    }
    return 0;
}

#define TOSAREF_ZERORANK_TENSOR_ALLOCATE(dtype)                                                                        \
    template <>                                                                                                        \
    int TosaReference::Tensor0<dtype>::allocate()                                                                      \
    {                                                                                                                  \
        ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");                                          \
        tensor = new ETensor0<dtype>();                                                                                \
                                                                                                                       \
        if (tensor)                                                                                                    \
            return 0;                                                                                                  \
        else                                                                                                           \
            return 1;                                                                                                  \
    }

#define TOSAREF_TENSOR_ALLOCATE(rank, dtype)                                                                           \
    template <>                                                                                                        \
    int TosaReference::Tensor##rank<dtype>::allocate()                                                                 \
    {                                                                                                                  \
        ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");                                          \
        std::array<Eigen::DenseIndex, rank> arrshape;                                                                  \
        std::copy_n(shape.begin(), rank, arrshape.begin());                                                            \
        tensor = new ETensor##rank<dtype>(arrshape);                                                                   \
                                                                                                                       \
        if (tensor)                                                                                                    \
            return 0;                                                                                                  \
        else                                                                                                           \
            return 1;                                                                                                  \
    }

TOSAREF_ZERORANK_TENSOR_ALLOCATE(double)
TOSAREF_TENSOR_ALLOCATE(1, double)
TOSAREF_TENSOR_ALLOCATE(2, double)
TOSAREF_TENSOR_ALLOCATE(3, double)
TOSAREF_TENSOR_ALLOCATE(4, double)
TOSAREF_TENSOR_ALLOCATE(5, double)
TOSAREF_TENSOR_ALLOCATE(6, double)
TOSAREF_ZERORANK_TENSOR_ALLOCATE(float)
TOSAREF_TENSOR_ALLOCATE(1, float)
TOSAREF_TENSOR_ALLOCATE(2, float)
TOSAREF_TENSOR_ALLOCATE(3, float)
TOSAREF_TENSOR_ALLOCATE(4, float)
TOSAREF_TENSOR_ALLOCATE(5, float)
TOSAREF_TENSOR_ALLOCATE(6, float)
TOSAREF_ZERORANK_TENSOR_ALLOCATE(int32_t)
TOSAREF_TENSOR_ALLOCATE(1, int32_t)
TOSAREF_TENSOR_ALLOCATE(2, int32_t)
TOSAREF_TENSOR_ALLOCATE(3, int32_t)
TOSAREF_TENSOR_ALLOCATE(4, int32_t)
TOSAREF_TENSOR_ALLOCATE(5, int32_t)
TOSAREF_TENSOR_ALLOCATE(6, int32_t)
TOSAREF_ZERORANK_TENSOR_ALLOCATE(int64_t)
TOSAREF_TENSOR_ALLOCATE(1, int64_t)
TOSAREF_TENSOR_ALLOCATE(2, int64_t)
TOSAREF_TENSOR_ALLOCATE(3, int64_t)
TOSAREF_TENSOR_ALLOCATE(4, int64_t)
TOSAREF_TENSOR_ALLOCATE(5, int64_t)
TOSAREF_TENSOR_ALLOCATE(6, int64_t)
TOSAREF_ZERORANK_TENSOR_ALLOCATE(bool)
TOSAREF_TENSOR_ALLOCATE(1, bool)
TOSAREF_TENSOR_ALLOCATE(2, bool)
TOSAREF_TENSOR_ALLOCATE(3, bool)
TOSAREF_TENSOR_ALLOCATE(4, bool)
TOSAREF_TENSOR_ALLOCATE(5, bool)
TOSAREF_TENSOR_ALLOCATE(6, bool)

template <>
int TosaReference::Tensor0<double>::dumpTensor(FILE* out) const
{
    char fp_fmt[32];
    snprintf(fp_fmt, sizeof(fp_fmt), "[ %%%sf ]\n", g_func_config.fp_format.c_str());

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, fp_fmt, (*tensor)(0));

    return 0;
}

template <>
int TosaReference::Tensor1<double>::dumpTensor(FILE* out) const
{
    char fp_fmt[32];
    snprintf(fp_fmt, sizeof(fp_fmt), " %%%sf ", g_func_config.fp_format.c_str());

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, fp_fmt, (*tensor)(i0));
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor2<double>::dumpTensor(FILE* out) const
{
    char fp_fmt[32];
    snprintf(fp_fmt, sizeof(fp_fmt), " %%%sf ", g_func_config.fp_format.c_str());

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, fp_fmt, (*tensor)(i0, i1));
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor3<double>::dumpTensor(FILE* out) const
{
    char fp_fmt[32];
    snprintf(fp_fmt, sizeof(fp_fmt), " %%%sf ", g_func_config.fp_format.c_str());

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, "[");
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                fprintf(out, fp_fmt, (*tensor)(i0, i1, i2));
            }
            fprintf(out, "]\n");
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor4<double>::dumpTensor(FILE* out) const
{
    char fp_fmt[32];
    snprintf(fp_fmt, sizeof(fp_fmt), " %%%sf ", g_func_config.fp_format.c_str());

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, "[");
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                fprintf(out, "[");
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    fprintf(out, fp_fmt, (*tensor)(i0, i1, i2, i3));
                }
                fprintf(out, "]\n");
            }
            fprintf(out, "]\n");
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor5<double>::dumpTensor(FILE* out) const
{
    char fp_fmt[32];
    snprintf(fp_fmt, sizeof(fp_fmt), " %%%sf ", g_func_config.fp_format.c_str());

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, "[");
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                fprintf(out, "[");
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    fprintf(out, "[");
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        fprintf(out, fp_fmt, (*tensor)(i0, i1, i2, i3, i4));
                    }
                    fprintf(out, "]\n");
                }
                fprintf(out, "]\n");
            }
            fprintf(out, "]\n");
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor6<double>::dumpTensor(FILE* out) const
{
    char fp_fmt[32];
    snprintf(fp_fmt, sizeof(fp_fmt), " %%%sf ", g_func_config.fp_format.c_str());

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, "[");
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                fprintf(out, "[");
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    fprintf(out, "[");
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        fprintf(out, "[");
                        for (int i5 = 0; i5 < shape[5]; i5++)
                        {
                            fprintf(out, fp_fmt, (*tensor)(i0, i1, i2, i3, i4, i5));
                        }
                        fprintf(out, "]\n");
                    }
                    fprintf(out, "]\n");
                }
                fprintf(out, "]\n");
            }
            fprintf(out, "]\n");
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor0<float>::dumpTensor(FILE* out) const
{
    char fp_fmt[32];
    snprintf(fp_fmt, sizeof(fp_fmt), "[ %%%sf ]\n", g_func_config.fp_format.c_str());

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, fp_fmt, (*tensor)(0));

    return 0;
}

template <>
int TosaReference::Tensor1<float>::dumpTensor(FILE* out) const
{
    char fp_fmt[32];
    snprintf(fp_fmt, sizeof(fp_fmt), " %%%sf ", g_func_config.fp_format.c_str());

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, fp_fmt, (*tensor)(i0));
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor2<float>::dumpTensor(FILE* out) const
{
    char fp_fmt[32];
    snprintf(fp_fmt, sizeof(fp_fmt), " %%%sf ", g_func_config.fp_format.c_str());

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, fp_fmt, (*tensor)(i0, i1));
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor3<float>::dumpTensor(FILE* out) const
{
    char fp_fmt[32];
    snprintf(fp_fmt, sizeof(fp_fmt), " %%%sf ", g_func_config.fp_format.c_str());

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, "[");
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                fprintf(out, fp_fmt, (*tensor)(i0, i1, i2));
            }
            fprintf(out, "]\n");
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor4<float>::dumpTensor(FILE* out) const
{
    char fp_fmt[32];
    snprintf(fp_fmt, sizeof(fp_fmt), " %%%sf ", g_func_config.fp_format.c_str());

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, "[");
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                fprintf(out, "[");
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    fprintf(out, fp_fmt, (*tensor)(i0, i1, i2, i3));
                }
                fprintf(out, "]\n");
            }
            fprintf(out, "]\n");
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor5<float>::dumpTensor(FILE* out) const
{
    char fp_fmt[32];
    snprintf(fp_fmt, sizeof(fp_fmt), " %%%sf ", g_func_config.fp_format.c_str());

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, "[");
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                fprintf(out, "[");
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    fprintf(out, "[");
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        fprintf(out, fp_fmt, (*tensor)(i0, i1, i2, i3, i4));
                    }
                    fprintf(out, "]\n");
                }
                fprintf(out, "]\n");
            }
            fprintf(out, "]\n");
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor6<float>::dumpTensor(FILE* out) const
{
    char fp_fmt[32];
    snprintf(fp_fmt, sizeof(fp_fmt), " %%%sf ", g_func_config.fp_format.c_str());

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, "[");
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                fprintf(out, "[");
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    fprintf(out, "[");
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        fprintf(out, "[");
                        for (int i5 = 0; i5 < shape[5]; i5++)
                        {
                            fprintf(out, fp_fmt, (*tensor)(i0, i1, i2, i3, i4, i5));
                        }
                        fprintf(out, "]\n");
                    }
                    fprintf(out, "]\n");
                }
                fprintf(out, "]\n");
            }
            fprintf(out, "]\n");
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor0<int64_t>::dumpTensor(FILE* out) const
{
    char i64_fmt[32];
    snprintf(i64_fmt, sizeof(i64_fmt), "[ %%ld ]\n");

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, i64_fmt, (*tensor)(0));

    return 0;
}

template <>
int TosaReference::Tensor1<int64_t>::dumpTensor(FILE* out) const
{
    char i64_fmt[32];
    snprintf(i64_fmt, sizeof(i64_fmt), " %%ld ");

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, i64_fmt, (*tensor)(i0));
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor2<int64_t>::dumpTensor(FILE* out) const
{
    char i64_fmt[32];
    snprintf(i64_fmt, sizeof(i64_fmt), " %%ld ");

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, i64_fmt, (*tensor)(i0, i1));
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor3<int64_t>::dumpTensor(FILE* out) const
{
    char i64_fmt[32];
    snprintf(i64_fmt, sizeof(i64_fmt), " %%ld ");

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, "[");
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                fprintf(out, i64_fmt, (*tensor)(i0, i1, i2));
            }
            fprintf(out, "]\n");
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor4<int64_t>::dumpTensor(FILE* out) const
{
    char i64_fmt[32];
    snprintf(i64_fmt, sizeof(i64_fmt), " %%ld ");

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, "[");
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                fprintf(out, "[");
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    fprintf(out, i64_fmt, (*tensor)(i0, i1, i2, i3));
                }
                fprintf(out, "]\n");
            }
            fprintf(out, "]\n");
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor5<int64_t>::dumpTensor(FILE* out) const
{
    char i64_fmt[32];
    snprintf(i64_fmt, sizeof(i64_fmt), " %%ld ");

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, "[");
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                fprintf(out, "[");
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    fprintf(out, "[");
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        fprintf(out, i64_fmt, (*tensor)(i0, i1, i2, i3, i4));
                    }
                    fprintf(out, "]\n");
                }
                fprintf(out, "]\n");
            }
            fprintf(out, "]\n");
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor6<int64_t>::dumpTensor(FILE* out) const
{
    char i64_fmt[32];
    snprintf(i64_fmt, sizeof(i64_fmt), " %%ld ");

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, "[");
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                fprintf(out, "[");
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    fprintf(out, "[");
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        fprintf(out, "[");
                        for (int i5 = 0; i5 < shape[5]; i5++)
                        {
                            fprintf(out, i64_fmt, (*tensor)(i0, i1, i2, i3, i4, i5));
                        }
                        fprintf(out, "]\n");
                    }
                    fprintf(out, "]\n");
                }
                fprintf(out, "]\n");
            }
            fprintf(out, "]\n");
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor0<int32_t>::dumpTensor(FILE* out) const
{
    char i32_fmt[32];
    snprintf(i32_fmt, sizeof(i32_fmt), "[ %%d ]\n");

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, i32_fmt, (*tensor)(0));

    return 0;
}

template <>
int TosaReference::Tensor1<int32_t>::dumpTensor(FILE* out) const
{
    char i32_fmt[32];
    snprintf(i32_fmt, sizeof(i32_fmt), " %%d ");

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, i32_fmt, (*tensor)(i0));
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor2<int32_t>::dumpTensor(FILE* out) const
{
    char i32_fmt[32];
    snprintf(i32_fmt, sizeof(i32_fmt), " %%d ");

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, i32_fmt, (*tensor)(i0, i1));
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor3<int32_t>::dumpTensor(FILE* out) const
{
    char i32_fmt[32];
    snprintf(i32_fmt, sizeof(i32_fmt), " %%d ");

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, "[");
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                fprintf(out, i32_fmt, (*tensor)(i0, i1, i2));
            }
            fprintf(out, "]\n");
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor4<int32_t>::dumpTensor(FILE* out) const
{
    char i32_fmt[32];
    snprintf(i32_fmt, sizeof(i32_fmt), " %%d ");

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, "[");
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                fprintf(out, "[");
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    fprintf(out, i32_fmt, (*tensor)(i0, i1, i2, i3));
                }
                fprintf(out, "]\n");
            }
            fprintf(out, "]\n");
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor5<int32_t>::dumpTensor(FILE* out) const
{
    char i32_fmt[32];
    snprintf(i32_fmt, sizeof(i32_fmt), " %%d ");

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, "[");
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                fprintf(out, "[");
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    fprintf(out, "[");
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        fprintf(out, i32_fmt, (*tensor)(i0, i1, i2, i3, i4));
                    }
                    fprintf(out, "]\n");
                }
                fprintf(out, "]\n");
            }
            fprintf(out, "]\n");
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor6<int32_t>::dumpTensor(FILE* out) const
{
    char i32_fmt[32];
    snprintf(i32_fmt, sizeof(i32_fmt), " %%d ");

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, "[");
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                fprintf(out, "[");
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    fprintf(out, "[");
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        fprintf(out, "[");
                        for (int i5 = 0; i5 < shape[5]; i5++)
                        {
                            fprintf(out, i32_fmt, (*tensor)(i0, i1, i2, i3, i4, i5));
                        }
                        fprintf(out, "]\n");
                    }
                    fprintf(out, "]\n");
                }
                fprintf(out, "]\n");
            }
            fprintf(out, "]\n");
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor0<bool>::dumpTensor(FILE* out) const
{
    char bool_fmt[32];
    snprintf(bool_fmt, sizeof(bool_fmt), "[ %%s ]\n");

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, bool_fmt, bool_to_str((*tensor)(0)));

    return 0;
}

template <>
int TosaReference::Tensor1<bool>::dumpTensor(FILE* out) const
{
    char bool_fmt[32];
    snprintf(bool_fmt, sizeof(bool_fmt), " %%s ");

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, bool_fmt, bool_to_str((*tensor)(i0)));
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor2<bool>::dumpTensor(FILE* out) const
{
    char bool_fmt[32];
    snprintf(bool_fmt, sizeof(bool_fmt), " %%s ");

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, bool_fmt, bool_to_str((*tensor)(i0, i1)));
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor3<bool>::dumpTensor(FILE* out) const
{
    char bool_fmt[32];
    snprintf(bool_fmt, sizeof(bool_fmt), " %%s ");

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, "[");
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                fprintf(out, bool_fmt, bool_to_str((*tensor)(i0, i1, i2)));
            }
            fprintf(out, "]\n");
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor4<bool>::dumpTensor(FILE* out) const
{
    char bool_fmt[32];
    snprintf(bool_fmt, sizeof(bool_fmt), " %%s ");

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, "[");
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                fprintf(out, "[");
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    fprintf(out, bool_fmt, bool_to_str((*tensor)(i0, i1, i2, i3)));
                }
                fprintf(out, "]\n");
            }
            fprintf(out, "]\n");
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor5<bool>::dumpTensor(FILE* out) const
{
    char bool_fmt[32];
    snprintf(bool_fmt, sizeof(bool_fmt), " %%s ");

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, "[");
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                fprintf(out, "[");
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    fprintf(out, "[");
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        fprintf(out, bool_fmt, bool_to_str((*tensor)(i0, i1, i2, i3, i4)));
                    }
                    fprintf(out, "]\n");
                }
                fprintf(out, "]\n");
            }
            fprintf(out, "]\n");
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <>
int TosaReference::Tensor6<bool>::dumpTensor(FILE* out) const
{
    char bool_fmt[32];
    snprintf(bool_fmt, sizeof(bool_fmt), " %%s ");

    if (tensor == nullptr)
    {
        fprintf(out, "<Not allocated>\n");
        return 0;
    }

    fprintf(out, "[");
    for (int i0 = 0; i0 < shape[0]; i0++)
    {
        fprintf(out, "[");
        for (int i1 = 0; i1 < shape[1]; i1++)
        {
            fprintf(out, "[");
            for (int i2 = 0; i2 < shape[2]; i2++)
            {
                fprintf(out, "[");
                for (int i3 = 0; i3 < shape[3]; i3++)
                {
                    fprintf(out, "[");
                    for (int i4 = 0; i4 < shape[4]; i4++)
                    {
                        fprintf(out, "[");
                        for (int i5 = 0; i5 < shape[5]; i5++)
                        {
                            fprintf(out, bool_fmt, bool_to_str((*tensor)(i0, i1, i2, i3, i4, i5)));
                        }
                        fprintf(out, "]\n");
                    }
                    fprintf(out, "]\n");
                }
                fprintf(out, "]\n");
            }
            fprintf(out, "]\n");
        }
        fprintf(out, "]\n");
    }
    fprintf(out, "]\n");

    return 0;
}

template <class T>
int TosaReference::TensorTemplate<T>::dumpTensor(FILE* out) const
{
    return 0;
}

// template explicit specialization
template class TosaReference::TensorTemplate<Eigen::Tensor<double, 0>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<double, 1>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<double, 2>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<double, 3>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<double, 4>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<double, 5>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<double, 6>>;

template class TosaReference::TensorTemplate<Eigen::Tensor<float, 0>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<float, 1>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<float, 2>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<float, 3>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<float, 4>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<float, 5>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<float, 6>>;

template class TosaReference::TensorTemplate<Eigen::Tensor<int32_t, 0>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<int32_t, 1>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<int32_t, 2>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<int32_t, 3>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<int32_t, 4>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<int32_t, 5>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<int32_t, 6>>;

template class TosaReference::TensorTemplate<Eigen::Tensor<int64_t, 0>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<int64_t, 1>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<int64_t, 2>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<int64_t, 3>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<int64_t, 4>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<int64_t, 5>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<int64_t, 6>>;

template class TosaReference::TensorTemplate<Eigen::Tensor<bool, 0>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<bool, 1>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<bool, 2>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<bool, 3>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<bool, 4>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<bool, 5>>;
template class TosaReference::TensorTemplate<Eigen::Tensor<bool, 6>>;