#include <gtest/gtest.h>
#include <chrono>
#include "CudaMatrix.h"
#include "Function.h"
#include "Matrix.h"
#include "TestUtility.h"

#include "Function2D.h"
#include "Function2D.cuh"

class Function2D_Cuda_Test:public ::testing::Test
{
protected:
    static void SetUpFunction2DCudaTester(){

    }
    static void TearDownTestCase(){
    }
    public:
    Aurora::Matrix B;
    Aurora::CudaMatrix dB;

    void SetUp(){

    }
    void TearDown(){
    }

};

TEST_F(Function2D_Cuda_Test, min)
{
    {
        float *dataB = Aurora::random(4096*41472);
        B = Aurora::Matrix::fromRawData(dataB, 4096, 41472);
        dB = B.toDeviceMatrix();
        long r,c;
        auto  start_time_ = std::chrono::high_resolution_clock::now();
        auto ret1 = Aurora::min(B, Aurora::FunctionDirection::Column,r,c);
        auto end_time = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
        start_time_ = std::chrono::high_resolution_clock::now();
        auto ret2 = Aurora::min(dB, Aurora::FunctionDirection::Column,r,c);
        end_time = std::chrono::high_resolution_clock::now();
        duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }

        start_time_ = std::chrono::high_resolution_clock::now();
        ret1 = Aurora::min(B, Aurora::FunctionDirection::Row,r,c);
        end_time = std::chrono::high_resolution_clock::now();
        duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
        start_time_ = std::chrono::high_resolution_clock::now();
        ret2 = Aurora::min(dB, Aurora::FunctionDirection::Row,r,c);
        end_time = std::chrono::high_resolution_clock::now();
        duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
    }
    {
        float *dataB = Aurora::random(3157*111);
        B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
        dB = B.toDeviceMatrix();
        long r,c;
        auto  start_time_ = std::chrono::high_resolution_clock::now();
        auto ret1 = Aurora::min(B, Aurora::FunctionDirection::Column,r,c);
        auto end_time = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
        start_time_ = std::chrono::high_resolution_clock::now();
        auto ret2 = Aurora::min(dB, Aurora::FunctionDirection::Column,r,c);
        end_time = std::chrono::high_resolution_clock::now();
        duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
        B.forceReshape( 111,3157, 1);
        dB = B.toDeviceMatrix();
        start_time_ = std::chrono::high_resolution_clock::now();
        ret1 = Aurora::min(B, Aurora::FunctionDirection::Column,r,c);
        end_time = std::chrono::high_resolution_clock::now();
        duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
        start_time_ = std::chrono::high_resolution_clock::now();
        ret2 = Aurora::min(dB, Aurora::FunctionDirection::Column,r,c);
        end_time = std::chrono::high_resolution_clock::now();
        duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
    }
    {
        float *dataB = Aurora::random(3157*111);
        B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
        dB = B.toDeviceMatrix();
        long r,c;
        auto  start_time_ = std::chrono::high_resolution_clock::now();

        auto ret1 = Aurora::min(B, 500.5f);
        auto end_time = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
        start_time_ = std::chrono::high_resolution_clock::now();
        auto ret2 = Aurora::min(dB, 500.5f);
        end_time = std::chrono::high_resolution_clock::now();
        duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
    }
    {
        float *dataB = Aurora::random(3157*111);
        float *dataA = Aurora::random(3157*111);
        auto A = Aurora::Matrix::fromRawData(dataA, 3157, 111);

        B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
        auto dA = A.toDeviceMatrix();
        dB = B.toDeviceMatrix();
        long r,c;
        auto  start_time_ = std::chrono::high_resolution_clock::now();

        auto ret1 = Aurora::min(B, A);
        auto end_time = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
        start_time_ = std::chrono::high_resolution_clock::now();
        auto ret2 = Aurora::min(dB, dA);
        end_time = std::chrono::high_resolution_clock::now();
        duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
    }
    {
        float *dataB = Aurora::random(3157*111);
        float *dataA = Aurora::random(3157);
        auto A = Aurora::Matrix::fromRawData(dataA, 3157, 1);

        B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
        auto dA = A.toDeviceMatrix();
        dB = B.toDeviceMatrix();
        long r,c;
        auto  start_time_ = std::chrono::high_resolution_clock::now();

        auto ret1 = Aurora::min(B, A);
        auto end_time = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
        start_time_ = std::chrono::high_resolution_clock::now();
        auto ret2 = Aurora::min(dB, dA);
        end_time = std::chrono::high_resolution_clock::now();
        duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
        start_time_ = std::chrono::high_resolution_clock::now();
        ret2 = Aurora::min(dA, dB);
        end_time = std::chrono::high_resolution_clock::now();
        duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
    }
    {
        float *dataB = Aurora::random(3157*111);
        float *dataA = Aurora::random(111);
        auto A = Aurora::Matrix::fromRawData(dataA, 1, 111);

        B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
        auto dA = A.toDeviceMatrix();
        dB = B.toDeviceMatrix();
        long r,c;
        auto  start_time_ = std::chrono::high_resolution_clock::now();

        auto ret1 = Aurora::min(B, A);
        auto end_time = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
        start_time_ = std::chrono::high_resolution_clock::now();
        auto ret2 = Aurora::min(dB, dA);
        end_time = std::chrono::high_resolution_clock::now();
        duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
    }
}

TEST_F(Function2D_Cuda_Test, max)
{
    {
        float *dataB = Aurora::random(4096*41472);
        B = Aurora::Matrix::fromRawData(dataB, 4096, 41472);
        dB = B.toDeviceMatrix();
        long r,c;
        auto  start_time_ = std::chrono::high_resolution_clock::now();
        auto ret1 = Aurora::max(B, Aurora::FunctionDirection::Column,r,c);
        auto end_time = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
        start_time_ = std::chrono::high_resolution_clock::now();
        auto ret2 = Aurora::max(dB, Aurora::FunctionDirection::Column,r,c);
        end_time = std::chrono::high_resolution_clock::now();
        duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }

        start_time_ = std::chrono::high_resolution_clock::now();
        ret1 = Aurora::max(B, Aurora::FunctionDirection::Row,r,c);
        end_time = std::chrono::high_resolution_clock::now();
        duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
        start_time_ = std::chrono::high_resolution_clock::now();
        ret2 = Aurora::max(dB, Aurora::FunctionDirection::Row,r,c);
        end_time = std::chrono::high_resolution_clock::now();
        duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
    }
    {
        float *dataB = Aurora::random(3157*111);
        B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
        dB = B.toDeviceMatrix();
        long r,c;
        auto  start_time_ = std::chrono::high_resolution_clock::now();
        auto ret1 = Aurora::max(B, Aurora::FunctionDirection::Column,r,c);
        auto end_time = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
        start_time_ = std::chrono::high_resolution_clock::now();
        auto ret2 = Aurora::max(dB, Aurora::FunctionDirection::Column,r,c);
        end_time = std::chrono::high_resolution_clock::now();
        duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
        B.forceReshape( 111,3157, 1);
        dB = B.toDeviceMatrix();
        start_time_ = std::chrono::high_resolution_clock::now();
        ret1 = Aurora::max(B, Aurora::FunctionDirection::Column,r,c);
        end_time = std::chrono::high_resolution_clock::now();
        duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
        start_time_ = std::chrono::high_resolution_clock::now();
        ret2 = Aurora::max(dB, Aurora::FunctionDirection::Column,r,c);
        end_time = std::chrono::high_resolution_clock::now();
        duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
    }
    {
        float *dataB = Aurora::random(3157*111);
        B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
        dB = B.toDeviceMatrix();
        long r,c;
        auto  start_time_ = std::chrono::high_resolution_clock::now();

        auto ret1 = Aurora::max(B, 500.5f);
        auto end_time = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
        start_time_ = std::chrono::high_resolution_clock::now();
        auto ret2 = Aurora::max(dB, 500.5f);
        end_time = std::chrono::high_resolution_clock::now();
        duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
    }
    {
        float *dataB = Aurora::random(3157*111);
        float *dataA = Aurora::random(3157*111);
        auto A = Aurora::Matrix::fromRawData(dataA, 3157, 111);

        B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
        auto dA = A.toDeviceMatrix();
        dB = B.toDeviceMatrix();
        long r,c;
        auto  start_time_ = std::chrono::high_resolution_clock::now();

        auto ret1 = Aurora::max(B, A);
        auto end_time = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
        start_time_ = std::chrono::high_resolution_clock::now();
        auto ret2 = Aurora::max(dB, dA);
        end_time = std::chrono::high_resolution_clock::now();
        duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
    }
    {
        float *dataB = Aurora::random(3157*111);
        float *dataA = Aurora::random(3157);
        auto A = Aurora::Matrix::fromRawData(dataA, 3157, 1);

        B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
        auto dA = A.toDeviceMatrix();
        dB = B.toDeviceMatrix();
        long r,c;
        auto  start_time_ = std::chrono::high_resolution_clock::now();

        auto ret1 = Aurora::max(B, A);
        auto end_time = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
        start_time_ = std::chrono::high_resolution_clock::now();
        auto ret2 = Aurora::max(dB, dA);
        end_time = std::chrono::high_resolution_clock::now();
        duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
        start_time_ = std::chrono::high_resolution_clock::now();
        ret2 = Aurora::max(dA, dB);
        end_time = std::chrono::high_resolution_clock::now();
        duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
    }
    {
        float *dataB = Aurora::random(3157*111);
        float *dataA = Aurora::random(111);
        auto A = Aurora::Matrix::fromRawData(dataA, 1, 111);

        B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
        auto dA = A.toDeviceMatrix();
        dB = B.toDeviceMatrix();
        long r,c;
        auto  start_time_ = std::chrono::high_resolution_clock::now();

        auto ret1 = Aurora::max(B, A);
        auto end_time = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
        start_time_ = std::chrono::high_resolution_clock::now();
        auto ret2 = Aurora::max(dB, dA);
        end_time = std::chrono::high_resolution_clock::now();
        duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
        std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
    }
}