// Copyright (c) 2020-2021, 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"

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

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

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

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

int TosaReference::Tensor::setIsSubgraphOutput()
{
    isSubgraphOutput = 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(), EnumNamesDType()[getDtype()],
            getIsValid(), getRank(), getShapeAsString().c_str());

    return 0;
}

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

    return 0;
}

int TosaReference::Tensor::readFromNpyFile(const char* filename)
{
    uint32_t elements   = getElementCount();
    float* fdatabuf     = nullptr;
    int32_t* i32databuf = nullptr;
    int64_t* i64databuf = nullptr;
    bool* bdatabuf      = nullptr;
    NumpyUtilities::NPError nperror;

    switch (getDtype())
    {
        case DType_FLOAT:
            fdatabuf = (float*)calloc(sizeof(float), elements);
            ASSERT_MEM(fdatabuf);

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

            nperror = NumpyUtilities::readFromNpyFile(filename, elements, i32databuf);
            break;
        case DType_INT48:
            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("unsupported tensor type=%s", EnumNamesDType()[getDtype()]);
    }

    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",
                        EnumNamesDType()[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 (getDtype())
    {
        case DType_FLOAT:
            if (setTensorValueFloat(elements, fdatabuf))
            {
                free(fdatabuf);
                return 1;
            }
            break;
        case DType_INT32:
        case DType_UINT8:
        case DType_INT4:
        case DType_INT8:
        case DType_INT16:
            if (setTensorValueInt32(elements, i32databuf))
            {
                free(i32databuf);
                return 1;
            }
            break;
        case DType_INT48:
            if (setTensorValueInt64(elements, i64databuf))
            {
                free(i64databuf);
                return 1;
            }
            break;
        case DType_BOOL:
            if (setTensorValueBool(elements, bdatabuf))
            {
                free(i32databuf);
                return 1;
            }
            break;
        default:
            FATAL_ERROR("unsupported tensor type=%s", EnumNamesDType()[getDtype()]);
    }

    setIsValid();

    if (fdatabuf)
        free(fdatabuf);
    if (i32databuf)
        free(i32databuf);
    if (i64databuf)
        free(i64databuf);
    if (bdatabuf)
        free(bdatabuf);

    return 0;
}

int TosaReference::Tensor::writeToNpyFile(const char* filename) const
{
    float* fdatabuf     = nullptr;
    int32_t* i32databuf = nullptr;
    int64_t* i64databuf = nullptr;
    bool* bdatabuf      = nullptr;
    NumpyUtilities::NPError nperror;
    int elements = getElementCount();

    switch (getDtype())
    {
        case DType_FLOAT:
            fdatabuf = (float*)calloc(sizeof(float), elements);
            ASSERT_MEM(fdatabuf);

            if (getTensorValueFloat(elements, fdatabuf))
            {
                free(fdatabuf);
                return 1;
            }

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

            free(fdatabuf);
            break;
        case DType_INT32:
        case DType_UINT8:
        case DType_INT4:
        case DType_INT8:
        case DType_INT16:
            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 DType_INT48:
            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 DType_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;
        default:
            FATAL_ERROR("unsupported tensor type=%s", EnumNamesDType()[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;                                                                                                  \
        }                                                                                                              \
                                                                                                                       \
        uint32_t src_rank = src->getRank();                                                                            \
        uint32_t dst_rank = this->getRank();                                                                           \
        DType src_dtype   = src->getDtype();                                                                           \
        DType 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, EnumNamesDType()[src_dtype], src->getShapeAsString().c_str(),    \
                    this->getName().c_str(), dst_rank, EnumNamesDType()[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, 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

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 <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>::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>::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;
}

template <>
int TosaReference::Tensor0<float>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor0<float>();

    if (tensor)
        return 0;
    else
        return 1;
}
template <>
int TosaReference::Tensor1<float>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor1<float>(shape[0]);
    if (tensor)
        return 0;
    else
        return 1;
}
template <>
int TosaReference::Tensor2<float>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor2<float>(shape[0], shape[1]);
    if (tensor)
        return 0;
    else
        return 1;
}

template <>
int TosaReference::Tensor3<float>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor3<float>(shape[0], shape[1], shape[2]);
    if (tensor)
        return 0;
    else
        return 1;
}

template <>
int TosaReference::Tensor4<float>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor4<float>(shape[0], shape[1], shape[2], shape[3]);
    if (tensor)
        return 0;
    else
        return 1;
}

template <>
int TosaReference::Tensor5<float>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor5<float>(shape[0], shape[1], shape[2], shape[3], shape[4]);
    if (tensor)
        return 0;
    else
        return 1;
}

template <>
int TosaReference::Tensor6<float>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor6<float>(shape[0], shape[1], shape[2], shape[3], shape[4], shape[5]);
    if (tensor)
        return 0;
    else
        return 1;
}

template <>
int TosaReference::Tensor0<int32_t>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor0<int32_t>();
    if (tensor)
        return 0;
    else
        return 1;
}
template <>
int TosaReference::Tensor1<int32_t>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor1<int32_t>(shape[0]);
    if (tensor)
        return 0;
    else
        return 1;
}
template <>
int TosaReference::Tensor2<int32_t>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor2<int32_t>(shape[0], shape[1]);
    if (tensor)
        return 0;
    else
        return 1;
}

template <>
int TosaReference::Tensor3<int32_t>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor3<int32_t>(shape[0], shape[1], shape[2]);
    if (tensor)
        return 0;
    else
        return 1;
}

template <>
int TosaReference::Tensor4<int32_t>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor4<int32_t>(shape[0], shape[1], shape[2], shape[3]);
    if (tensor)
        return 0;
    else
        return 1;
}

template <>
int TosaReference::Tensor5<int32_t>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor5<int32_t>(shape[0], shape[1], shape[2], shape[3], shape[4]);
    if (tensor)
        return 0;
    else
        return 1;
}

template <>
int TosaReference::Tensor6<int32_t>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor6<int32_t>(shape[0], shape[1], shape[2], shape[3], shape[4], shape[5]);
    if (tensor)
        return 0;
    else
        return 1;
}

template <>
int TosaReference::Tensor0<int64_t>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor0<int64_t>();
    if (tensor)
        return 0;
    else
        return 1;
}
template <>
int TosaReference::Tensor1<int64_t>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor1<int64_t>(shape[0]);
    if (tensor)
        return 0;
    else
        return 1;
}
template <>
int TosaReference::Tensor2<int64_t>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor2<int64_t>(shape[0], shape[1]);
    if (tensor)
        return 0;
    else
        return 1;
}

template <>
int TosaReference::Tensor3<int64_t>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor3<int64_t>(shape[0], shape[1], shape[2]);
    if (tensor)
        return 0;
    else
        return 1;
}

template <>
int TosaReference::Tensor4<int64_t>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor4<int64_t>(shape[0], shape[1], shape[2], shape[3]);
    if (tensor)
        return 0;
    else
        return 1;
}

template <>
int TosaReference::Tensor5<int64_t>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor5<int64_t>(shape[0], shape[1], shape[2], shape[3], shape[4]);
    if (tensor)
        return 0;
    else
        return 1;
}

template <>
int TosaReference::Tensor6<int64_t>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor6<int64_t>(shape[0], shape[1], shape[2], shape[3], shape[4], shape[5]);
    if (tensor)
        return 0;
    else
        return 1;
}

template <>
int TosaReference::Tensor0<bool>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor0<bool>();
    if (tensor)
        return 0;
    else
        return 1;
}
template <>
int TosaReference::Tensor1<bool>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor1<bool>(shape[0]);
    if (tensor)
        return 0;
    else
        return 1;
}
template <>
int TosaReference::Tensor2<bool>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor2<bool>(shape[0], shape[1]);
    if (tensor)
        return 0;
    else
        return 1;
}

template <>
int TosaReference::Tensor3<bool>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor3<bool>(shape[0], shape[1], shape[2]);
    if (tensor)
        return 0;
    else
        return 1;
}

template <>
int TosaReference::Tensor4<bool>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor4<bool>(shape[0], shape[1], shape[2], shape[3]);
    if (tensor)
        return 0;
    else
        return 1;
}

template <>
int TosaReference::Tensor5<bool>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor5<bool>(shape[0], shape[1], shape[2], shape[3], shape[4]);
    if (tensor)
        return 0;
    else
        return 1;
}

template <>
int TosaReference::Tensor6<bool>::allocate()
{
    ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor");
    tensor = new ETensor6<bool>(shape[0], shape[1], shape[2], shape[3], shape[4], shape[5]);
    if (tensor)
        return 0;
    else
        return 1;
}

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

    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[FOF_STR_LEN];
    snprintf(fp_fmt, FOF_STR_LEN, " %%%sf ", g_func_config.fp_format);

    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[FOF_STR_LEN];
    snprintf(fp_fmt, FOF_STR_LEN, " %%%sf ", g_func_config.fp_format);

    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[FOF_STR_LEN];
    snprintf(fp_fmt, FOF_STR_LEN, " %%%sf ", g_func_config.fp_format);

    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[FOF_STR_LEN];
    snprintf(fp_fmt, FOF_STR_LEN, " %%%sf ", g_func_config.fp_format);

    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[FOF_STR_LEN];
    snprintf(fp_fmt, FOF_STR_LEN, " %%%sf ", g_func_config.fp_format);

    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[FOF_STR_LEN];
    snprintf(fp_fmt, FOF_STR_LEN, " %%%sf ", g_func_config.fp_format);

    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[FOF_STR_LEN];
    snprintf(i64_fmt, FOF_STR_LEN, "[ %%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[FOF_STR_LEN];
    snprintf(i64_fmt, FOF_STR_LEN, " %%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[FOF_STR_LEN];
    snprintf(i64_fmt, FOF_STR_LEN, " %%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[FOF_STR_LEN];
    snprintf(i64_fmt, FOF_STR_LEN, " %%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[FOF_STR_LEN];
    snprintf(i64_fmt, FOF_STR_LEN, " %%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[FOF_STR_LEN];
    snprintf(i64_fmt, FOF_STR_LEN, " %%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[FOF_STR_LEN];
    snprintf(i64_fmt, FOF_STR_LEN, " %%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[FOF_STR_LEN];
    snprintf(i32_fmt, FOF_STR_LEN, "[ %%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[FOF_STR_LEN];
    snprintf(i32_fmt, FOF_STR_LEN, " %%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[FOF_STR_LEN];
    snprintf(i32_fmt, FOF_STR_LEN, " %%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[FOF_STR_LEN];
    snprintf(i32_fmt, FOF_STR_LEN, " %%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[FOF_STR_LEN];
    snprintf(i32_fmt, FOF_STR_LEN, " %%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[FOF_STR_LEN];
    snprintf(i32_fmt, FOF_STR_LEN, " %%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[FOF_STR_LEN];
    snprintf(i32_fmt, FOF_STR_LEN, " %%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[FOF_STR_LEN];
    snprintf(bool_fmt, FOF_STR_LEN, "[ %%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[FOF_STR_LEN];
    snprintf(bool_fmt, FOF_STR_LEN, " %%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[FOF_STR_LEN];
    snprintf(bool_fmt, FOF_STR_LEN, " %%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[FOF_STR_LEN];
    snprintf(bool_fmt, FOF_STR_LEN, " %%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[FOF_STR_LEN];
    snprintf(bool_fmt, FOF_STR_LEN, " %%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[FOF_STR_LEN];
    snprintf(bool_fmt, FOF_STR_LEN, " %%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[FOF_STR_LEN];
    snprintf(bool_fmt, FOF_STR_LEN, " %%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<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>>;